windows-xp/Source/XPSP1/NT/termsrv/remdsk/rds/t120/mst120/connect.cpp

#include "precomp.h"
DEBUG_FILEZONE(ZONE_T120_MCSNC);
/*
 *	connect.cpp
 *
 *	Copyright (c) 1993 - 1995 by DataBeam Corporation, Lexington, KY
 *
 *	Abstract:
 *		This is the implementation file for class Connection.  It contains
 *		all code necessary to encode MCS commands as T.125 PDUs, and to
 *		decode T.125 back into MCS commands.
 *
 *		The primary responsibility of this class is to act as a Remote
 *		Procedure Call facility for MCS commands.  A CommandTarget object
 *		uses a Connection object to encode an MCS command as a PDU, and send it
 *		across to a remote Connection object.  That Connection object will
 *		decode the PDU back into an MCS command, at which time it will send
 *		it to the attached CommandTarget object on that side.  The intervening
 *		transport layer is transparent to the CommandTargets utilizing
 *		Connection class services.
 *
 *		A secondary responsibility of this class is to provide a layer of
 *		flow control between the attached CommandTarget object and the
 *		transport layer.  PDUs are queued until the transport layer can take
 *		them.
 *
 *	Private Instance Variables:
 *		Encoding_Rules
 *			This is a variable which holds a value indicating what type of
 *			rules (Basic or Packed) are used for encoding and decoding the PDUs.
 *		m_pDomain
 *			This is a pointer to the domain to which this connection is bound.
 *		m_pPendingDomain
 *			This is a pointer to the domain to which this connection will be
 *			bound upon successful completion of the	connection process.
 *		Connection_Handle
 *			This is the handle for the current transport connection.  It allows
 *			callback functions to be associated with the current transport
 *			connection so that any events which occur on this transport
 *			connection will be routed to any object that has registered its
 *			callbacks.
 *		m_pszCalledAddress
 *			The transport address of the party being called.
 *		Upward_Connection
 *			This is a boolean flag which indicates whether or not this is
 *			an upward connection.
 *		Domain_Parameters
 *			This is a structure which holds the set of domain parameters
 *			associated with this connection.
 *		Connect_Response_Memory
 *			This is a pointer to a memory object which is used to hold any
 *			user data contained within a ConnectResponse PDU.
 *		Merge_In_Progress
 *			This is a boolean flag that indicates whether or not the attached
 *			Domain object is in the merge state.  When in the merge state it
 *			is invalid to send it any MCS commands.
 *		Domain_Traffic_Allowed
 *			This is a boolean flag used to indicate when this connection object
 *			has been successfully created and bound to the domain, thus allowing
 *			PDU traffic to commence.
 *		Connect_Provider_Confirm_Pending
 *			This is a boolean flag used to dictate the behavior if this
 *			connection becomes invalid.  If a connect provider confirm is
 *			pending when the connection becomes invalid, then a failed confirm
 *			is issued to the controller.  If there is not a confirm pending,
 *			then we simply issue a delete connection to the controller.
 *		Transport_Connection
 *			This is an array used to hold handles for the transport connections
 *			available for use by this connection object.  There is a transport
 *			connection associated with each of the four data priorities.
 *		Transport_Connection_PDU_Type
 *			This is an array which holds values indicating what type of PDU
 *			(Connect or Domain) is expected for each priority level.
 *		Transport_Connection_State
 *			This is an array which holds values indicating the state of the
 *			transport connection associated with each prioriy level.
 *		Transport_Connection_Count
 *			This is a counter which keeps track of the number of transport
 *			connections.
 *		m_OutPktQueue
 *			This is a queue used to hold data units to be transmitted.
 *
 *	Private Member Functions:
 *		ConnectInitial
 *			This routine is called by the domain when a connection is being
 *			created.  It places the necessary domain information into a data
 *			packet and queues the data to be transmitted through the transport
 *			interface.
 *		ConnectResponse
 *			This routine is called when issuing a response to a	
 *			"ConnectInitial" PDU.  The result of the attempted connection, the
 *			connection ID, the domain parameters, and any user data are all put
 *			into the packet and queued for transmission through the transport
 *			interface.  If the result of the attempted connection is negative,
 *			the controller and transport interface are notified.
 *		ConnectAdditional
 *			This routine is called after successfully processing a
 *			"ConnectResponse" PDU in order to create any addition necessary
 *			transport connections.
 *		ConnectResult
 *			This routine is called indirectly when issuing a positive response
 *			to a "ConnectAdditional" PDU.  The "ConnectAdditional" PDUs are
 *			processed by the controller and therefore any negative
 *			"ConnectResult" PDU will be issued by the controller.
 *		ProcessConnectResponse
 *			This routine processes "Connect Response" PDU's coming from the
 *			transport interface.  Domain parameters are retrieved and the
 *			PDU sent on to the proper domain.
 *		ProcessConnectResult
 *			This routine processes "Connect Result" PDU's coming from the
 *			transport interface.  For successful "Connect Result" PDU's this
 *			connection is bound to the domain and a positive Connect Provider
 *			Confirm issued to the controller.  If unsuccessful, a negative
 *			Connect Provider Confirm is issued to the controller.
 *		IssueConnectProviderConfirm
 *			This routine is called in order to send a "Connect Provider Confirm"
 *			to the controller through a callback.
 *		DestroyConnection
 *			This routine is called in order to delete this connection because it
 *			has become invalid.  This is done by issuing a failed confirm to the
 *			controller or, if no confirm is pending, by issuing a delete
 *			connection to the controller.
 *		AssignRemainingTransportConnections
 *			This routine is called when there are no more transport connections
 *			to create in order to copy the lowest priority transport connection
 *			into all unassigned priorities.
 *		CreateTransportConnection
 *			This routine is called in order to create new transport connections.
 *		AcceptTransportConnection
 *			This routine is called in order to register this connection object
 *			with the transport interface.
 *		AdjustDomainParameters
 *			This routine is called in order to adjust the domain parameters so
 *			that they fall within the allowable range.
 *		MergeDomainParameters
 *			This routine is called in order to calculate the optimum overlap
 *			between the local and remote domain parameters.  If there is no
 *			overlap, this routine will return a value causing this connection
 *			to be destroyed.
 *		PrintDomainParameters
 *			This routine is used for debug purposes in order to print out the
 *			current set of domain parameters.
 *		SendPacket
 *			This routine is called in order to create a packet which will hold
 *			the PDU to be sent to the remote provider.  The packet will be
 *			queued up for transmission through the transport interface.
 *		QueueForTransmission
 *			This routine places data units into the transmission queue so
 *			they can be transmitted through the transport interface when
 *			possible.
 *		ProcessMergeChannelsRequest
 *			This routine processes "Merge Channel Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessMergeChannelsConfirm
 *			This routine processes "Merge Channel Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessPurgeChannelsIndication
 *			This routine processes "Purge Channel Indication" PDU's coming from
 *			the transport interface by retrieving any necessary information from
 *			the	packet and sending the PDU on to the proper domain.
 *		ProcessMergeTokenRequest
 *			This routine processes "Merge Token Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessMergeTokenConfirm
 *			This routine processes "Merge Token Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessPurgeTokenIndication
 *			This routine processes "Purge Token Indication" PDU's coming from
 *			the transport interface by retrieving any necessary information from
 *			the	packet and sending the PDU on to the proper domain.
 *		ProcessDisconnectProviderUltimatum
 *			This routine processes "Disconnect Provider Ultimatum" PDU's coming
 *			from the transport interface by retrieving any necessary information
 *			from the packet and sending the PDU on to the proper domain.
 *		ProcessAttachUserRequest
 *			This routine processes "Attach User Request" PDU's coming from the
 *			transport interface by sending the PDU on to the proper domain.
 *		ProcessAttachUserConfirm
 *			This routine processes "Attach User Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessDetachUserRequest
 *			This routine processes "Detach User Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessDetachUserIndication
 *			This routine processes "Detach User Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessChannelJoinRequest
 *			This routine processes "Channel Join Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessChannelJoinConfirm
 *			This routine processes "Channel Join Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessChannelLeaveRequest
 *			This routine processes "Channel Leave Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessChannelConveneRequest
 *			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.
 *		ProcessChannelConveneConfirm
 *			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.
 *		ProcessChannelDisbandRequest
 *			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.
 *		ProcessChannelDisbandIndication
 *			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.
 *		ProcessChannelAdmitRequest
 *			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.
 *		ProcessChannelAdmitIndication
 *			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.
 *		ProcessChannelExpelRequest
 *			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.
 *		ProcessChannelExpelIndication
 *			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.
 *		ProcessSendDataRequest
 *			This routine processes "Send Data Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet, allocating any memory needed, and sending the PDU on to the
 *			proper domain.
 *		ProcessSendDataIndication
 *			This routine processes "Send Data Indication" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet, allocating any memory needed, and sending the PDU on to the
 *			proper domain.
 *		ProcessUniformSendDataRequest
 *			This routine processes "Uniform Send Data Indication" PDU's coming
 *			from the transport interface by retrieving any necessary information
 *			from the packet, allocating any memory needed, and sending the PDU
 *			on to the proper domain.
 *		ProcessUniformSendDataIndication
 *			This routine processes "Uniform Send Data Indication" PDU's coming
 *			from the transport interface by retrieving any necessary information
 *			from the packet, allocating any memory needed, and sending the PDU
 *			on to the proper domain.
 *		ProcessTokenGrabRequest
 *			This routine processes "Token Grab Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenGrabConfirm
 *			This routine processes "Token Grab Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenInhibitRequest
 *			This routine processes "Token Inhibit Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenInhibitConfirm
 *			This routine processes "Token Inhibit Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenReleaseRequest
 *			This routine processes "Token Release Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenReleaseConfirm
 *			This routine processes "Token Release Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenTestRequest
 *			This routine processes "Token Test Request" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenTestConfirm
 *			This routine processes "Token Test Confirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessRejectUltimatum
 *			This routine processes "RejectUltimatum" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenGiveRequest
 *			This routine processes "TokenGiveRequest" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenGiveIndication
 *			This routine processes "TokenGiveIndication" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenGiveResponse
 *			This routine processes "TokenGiveResponse" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenGiveConfirm
 *			This routine processes "TokenGiveConfirm" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenPleaseRequest
 *			This routine processes "TokenPleaseRequest" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessTokenPleaseIndication
 *			This routine processes "TokenPleaseIndication" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessPlumbDomainIndication
 *			This routine processes "PlumbDomainIndication" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ProcessErectDomainRequest
 *			This routine processes "ErectDomainRequest" PDU's coming from the
 *			transport interface by retrieving any necessary information from the
 *			packet and sending the PDU on to the proper domain.
 *		ValidateConnectionRequest
 *			This function is used to determine if it is valid to process an
 *			incoming request at the current time.
 *
 *	Caveats:
 *		None.
 *
 *	Author:
 *		James P. Galvin, Jr.
 *		John B. O'Nan
 */

/*
 *	External Interfaces
 */
#include "omcscode.h"
#include "tprtntfy.h"
#include "plgxprt.h"

/*
 *	This is a global variable that has a pointer to the one MCS coder that
 *	is instantiated by the MCS Controller.  Most objects know in advance
 *	whether they need to use the MCS or the GCC coder, so, they do not need
 *	this pointer in their constructors.
 */
extern CMCSCoder	*g_MCSCoder;

// The external MCS Controller object
extern PController	g_pMCSController;

// The global TransportInterface pointer (for transport access)
extern PTransportInterface g_Transport;

/*
 *	Connection ()
 *
 *	Public
 *
 *	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.
 *
 *	Caveats:
 *		None.
 */
Connection::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
)
:
    CAttachment(CONNECT_ATTACHMENT),
    Encoding_Rules (BASIC_ENCODING_RULES),
    m_pDomain(NULL),
    m_pPendingDomain(attachment),
    Connection_Handle (connection_handle),
    Upward_Connection (upward_connection),
    Deletion_Reason (REASON_USER_REQUESTED),
    Connect_Response_Memory (NULL),
    Merge_In_Progress (FALSE),
    Domain_Traffic_Allowed (FALSE),
    Connect_Provider_Confirm_Pending (TRUE),
    m_fSecure(fSecure)
{
	UINT					priority;
	TransportError			transport_error;
	DomainParameters		min_domain_parameters;
	DomainParameters		max_domain_parameters;

    BOOL fPluggableTransport = ::GetPluggableTransportConnID((LPCSTR) called_address);

	/*
	 *	If the passed in pointer is valid, then set the local domain
	 *	parameters to the values contained therein.  Otherwise, use
	 *	defaults for everything.
	 */
	if (domain_parameters != NULL)
		Domain_Parameters = *domain_parameters;
	else
	{
		/*
		 *	Use default values for all domain parameters.
		 */
		Domain_Parameters.max_channel_ids = DEFAULT_MAXIMUM_CHANNELS;
		Domain_Parameters.max_user_ids = DEFAULT_MAXIMUM_USERS;
		Domain_Parameters.max_token_ids = DEFAULT_MAXIMUM_TOKENS;
		Domain_Parameters.number_priorities = DEFAULT_NUMBER_OF_PRIORITIES;
		Domain_Parameters.min_throughput = DEFAULT_MINIMUM_THROUGHPUT;
		Domain_Parameters.max_height = DEFAULT_MAXIMUM_DOMAIN_HEIGHT;
		Domain_Parameters.max_mcspdu_size = DEFAULT_MAXIMUM_PDU_SIZE;
		Domain_Parameters.protocol_version = DEFAULT_PROTOCOL_VERSION;

		if (fPluggableTransport || g_fWinsockDisabled)
		{
    		Domain_Parameters.number_priorities = DEFAULT_NUM_PLUGXPRT_PRIORITIES;
		}
	}

	/*
	 *	Initialize the arrays indicating that the transport connections
	 *	are not yet valid, and that none of the queues have data in them
	 *	yet.
	 */
	for (priority = 0; priority < MAXIMUM_PRIORITIES; priority++)
	{
		Transport_Connection_State[priority] = TRANSPORT_CONNECTION_UNASSIGNED;
	}
	Transport_Connection_Count = 0;

	if (NULL == (m_pszCalledAddress = ::My_strdupA(called_address)))
	{
		ERROR_OUT(("Connection::Connection: can't create called address"));
		*connection_error = MCS_ALLOCATION_FAILURE;
		return;
	}

	/*
	 *	Send a connect request to the transport layer to create the Top
	 *	Priority transport connection.
	 */
	transport_error = CreateTransportConnection (m_pszCalledAddress, m_fSecure, TOP_PRIORITY);

	if (transport_error == TRANSPORT_NO_ERROR)
	{
		/*
		 *	Call upon the domain to find out the appropriate minimum and
		 *	maximum domain parameter values.  Then call a private member
		 *	function to adjust the target parameters to fit into that range.
		 */
		m_pPendingDomain->GetDomainParameters(NULL, &min_domain_parameters,
                                                    &max_domain_parameters);
		AdjustDomainParameters (&min_domain_parameters, &max_domain_parameters,
				&Domain_Parameters);

#ifdef DEBUG
		TRACE_OUT (("Connection::Connection: CONNECT_INITIAL target parameters"));
		PrintDomainParameters (&Domain_Parameters);
		TRACE_OUT (("Connection::Connection: CONNECT_INITIAL minimum parameters"));
		PrintDomainParameters (&min_domain_parameters);
		TRACE_OUT (("Connection::Connection: CONNECT_INITIAL maximum parameters"));
		PrintDomainParameters (&max_domain_parameters);
#endif // DEBUG

		/*
		 *	Issue the ConnectInitial on the newly created transport
		 *	connection.  Note that the queue will not actually try to
		 *	send the data until the confirm is received from the
		 *	transport layer.
		 */
		ConnectInitial (calling_domain, called_domain, Upward_Connection,
				&Domain_Parameters, &min_domain_parameters,
				&max_domain_parameters, user_data, user_data_length);

		*connection_error = MCS_NO_ERROR;
	}
	else
	{
		WARNING_OUT (("Connection::Connection: transport ConnectRequest failed"));

		/*
		 *	Set the return code according to the nature of the failure.
		 */
		switch (transport_error)
		{
			case TRANSPORT_MEMORY_FAILURE:
				*connection_error = MCS_ALLOCATION_FAILURE;
				break;
					
			case TRANSPORT_SECURITY_FAILED:
				*connection_error = MCS_SECURITY_FAILED;
				break;

			default:
				*connection_error = MCS_TRANSPORT_NOT_READY;
				break;
		}
	}
}

/*
 *	Connection ()
 *
 *	Public
 *
 *	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.
 *
 *	Caveats:
 *		None.
 */
Connection::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)
:
    CAttachment(CONNECT_ATTACHMENT),
    m_pszCalledAddress(NULL),
    Encoding_Rules (BASIC_ENCODING_RULES),
    m_pDomain(NULL),
    m_pPendingDomain(attachment),
    Connection_Handle (connection_handle),
    Upward_Connection (upward_connection),
    Deletion_Reason (REASON_USER_REQUESTED),
    Connect_Response_Memory (NULL),
    Merge_In_Progress (FALSE),
    Domain_Traffic_Allowed (FALSE),
    Connect_Provider_Confirm_Pending (FALSE)
{
	UINT				priority;
	TransportError		transport_error;
	DomainParameters	local_min_domain_parameters;
	DomainParameters	local_max_domain_parameters;

	//
	// BUGBUG: set m_fSecure from transport connection?
	//

	/*
	 *	If the passed in pointer is valid, then set the local domain
	 *	parameters to the values contained therein.  Otherwise, use
	 *	defaults for everything.
	 */
	if (domain_parameters != NULL)
		Domain_Parameters = *domain_parameters;
	else
	{
		/*
		 *	Use default values for all domain parameters.
		 */
		Domain_Parameters.max_channel_ids = DEFAULT_MAXIMUM_CHANNELS;
		Domain_Parameters.max_user_ids = DEFAULT_MAXIMUM_USERS;
		Domain_Parameters.max_token_ids = DEFAULT_MAXIMUM_TOKENS;
		Domain_Parameters.number_priorities = DEFAULT_NUMBER_OF_PRIORITIES;
		Domain_Parameters.min_throughput = DEFAULT_MINIMUM_THROUGHPUT;
		Domain_Parameters.max_height = DEFAULT_MAXIMUM_DOMAIN_HEIGHT;
		Domain_Parameters.max_mcspdu_size = DEFAULT_MAXIMUM_PDU_SIZE;
		Domain_Parameters.protocol_version = DEFAULT_PROTOCOL_VERSION;

		if (IS_PLUGGABLE(transport_connection) || g_fWinsockDisabled)
		{
    		Domain_Parameters.number_priorities = DEFAULT_NUM_PLUGXPRT_PRIORITIES;
		}
	}

	/*
	 *	Initialize the arrays indicating that the transport connections
	 *	are not yet valid, and that none of the queues have data in them
	 *	yet.
	 */
	for (priority=0; priority < MAXIMUM_PRIORITIES; priority++)
	{
		Transport_Connection_State[priority] = TRANSPORT_CONNECTION_UNASSIGNED;
	}
	Transport_Connection_Count = 0;

	transport_error = AcceptTransportConnection (transport_connection,
			TOP_PRIORITY);

	if (transport_error == TRANSPORT_NO_ERROR)
	{
		/*
		 *	Call the domain object to find out the local minimum and maximum
		 *	permissible values for the domain parameters.
		 */
		m_pPendingDomain->GetDomainParameters (NULL, &local_min_domain_parameters,
		                                             &local_max_domain_parameters);

		/*
		 *	Now call a private member function to calculate the optimum overlap
		 *	between the local and remote domain parameters.  Note that if there
		 *	is no overlap, this connection will be destroyed.
		 */
		if (MergeDomainParameters (min_domain_parameters, max_domain_parameters,
				&local_min_domain_parameters, &local_max_domain_parameters))
		{
			/*
			 *	The merge of the domain parameters was acceptable, so now we
			 *	must adjust the target parameters to fit within the agreed
			 *	upon range.
			 */
			AdjustDomainParameters (&local_min_domain_parameters,
					&local_max_domain_parameters, &Domain_Parameters);

#ifdef DEBUG
			TRACE_OUT (("Connection::Connection: CONNECT_RESPONSE parameters"));
			PrintDomainParameters (&Domain_Parameters);
#endif // DEBUG

			/*
			 *	Issue the ConnectResponse on the new transport connection.
			 */
			ConnectResponse (RESULT_SUCCESSFUL, &Domain_Parameters,
					Connection_Handle, user_data, user_data_length);

			/*
			 *	Check to see if this completes the list of transport
			 *	connections that will be used in this MCS connection.
			 */
			if (Transport_Connection_Count == Domain_Parameters.number_priorities)
			{
				/*
				 *	There are no more transport connections to accept.  We must
				 *	now assign the lowest priority TC to all unassigned
				 *	priorities.
				 */
				AssignRemainingTransportConnections ();
			}
			else
			{
				/*
				 *	Issue a ConnectResult for each remaining priority.  Note
				 *	that these TCs have not been created yet, so the PDUs will
				 *	remain in the queue until they are created.  They are put in
				 *	the queue here to assure that they are the first PDUs
				 *	transmitted over a given TC.
				 */
				for (priority = Transport_Connection_Count;
						priority < Domain_Parameters.number_priorities;
						priority++)
					ConnectResult (RESULT_SUCCESSFUL, (Priority) priority);
			}

			/*
			 *	Now that we know what the domain parameters will be for this
			 *	connection, we can determine what type of encoding rules will
			 *	be used for domain PDUs (basic or packed).
			 */
#if 0
			if (Domain_Parameters.protocol_version == PROTOCOL_VERSION_BASIC)
			{
				TRACE_OUT(("Connection::Connection: using basic encoding rules"));
				Encoding_Rules = BASIC_ENCODING_RULES;
			}
			else
#endif  // 0
			{
				TRACE_OUT (("Connection::Connection: using packed encoding rules"));
				Encoding_Rules = PACKED_ENCODING_RULES;
			}


			/*
			 *	Bind the pending attachment to the domain.  Note that this
			 *	is necessary on the called provider in order to allow access
			 *	to domain services immediately after the return from
			 *	MCSConnectProviderResponse (which is what got us here).
			 */
			TRACE_OUT (("Connection::Connection: binding MCS connection to domain"));
			m_pDomain = m_pPendingDomain;
			m_pDomain->BindConnAttmnt(this, Upward_Connection, &Domain_Parameters);

			*connection_error = MCS_NO_ERROR;
		}
		else
		{
			/*
			 *	Issue the ConnectResponse informing the remote side that the
			 *	domain parameters are unacceptable.  We must flush the message
			 *	queue from here to force the response packet to be transmitted.
			 *	This is because this object will be deleted by the controller
			 *	as soon as this call returns.
			 */
			WARNING_OUT (("Connection::Connection: "
					"unacceptable domain parameters"));
			ConnectResponse (RESULT_PARAMETERS_UNACCEPTABLE, &Domain_Parameters,
					Connection_Handle, user_data, user_data_length);
			FlushMessageQueue ();
			*connection_error = MCS_DOMAIN_PARAMETERS_UNACCEPTABLE;
		}
	}
	else
	{
		WARNING_OUT (("Connection::Connection: "
				"register transport connection failed"));
		*connection_error = MCS_NO_SUCH_CONNECTION;
	}
}

/*
 *	~Connection ()
 *
 *	Public
 *
 *	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.
 *
 *	Caveats:
 *		None.
 */
Connection::~Connection ()
{
	DomainMCSPDU		disconnect_provider_ultimatum_pdu;
	PSimplePacket		packet;
	PacketError			packet_error;
	UShort				priority;

	/*
	 *	If we still have an upward attachment, then issue a disconnect
	 *	provider ultimatum to terminate it.
	 */
	if (m_pDomain != NULL)
		m_pDomain->DisconnectProviderUltimatum(this, Deletion_Reason);

	/*
	 *	Check to see if the Top Priority transport connection is still valid.
	 *	If so, we need to try and send a disconnect ultimatum PDU through it
	 *	before hanging up.
	 */
	if (Transport_Connection_State[TOP_PRIORITY] == TRANSPORT_CONNECTION_READY)
	{
		/*
		 *	We must first purge all packets that are waiting in the transport
		 *	queue, to expediate the disconnect process.
		 */
		::PurgeRequest (Transport_Connection[TOP_PRIORITY]);
		
		/*
		 *	If there are any remaining data units in the queue for this
		 *	priority, walk through the list releasing all memory associated
		 *	with them.
		 */
		while (NULL != (packet = m_OutPktQueue[TOP_PRIORITY].Get()))
		{
			packet->Unlock();
		}

		if (Domain_Traffic_Allowed)
		{
				PPacket		disconnect_packet;
			/*
			 *	Fill in the PDU structure to be encoded.
			 */
			disconnect_provider_ultimatum_pdu.choice =
					DISCONNECT_PROVIDER_ULTIMATUM_CHOSEN;
			disconnect_provider_ultimatum_pdu.u.
					disconnect_provider_ultimatum.reason =
					(PDUReason)Deletion_Reason;

			/*
			 *	Create a packet which will be used to hold the data to be sent
			 *	through the transport interface.  If the packet creation fails it
			 *	doesn't matter since this connection is being deleted anyway.
			 */
			DBG_SAVE_FILE_LINE
			disconnect_packet = new Packet (
								 		(PPacketCoder) g_MCSCoder,
										Encoding_Rules,
										(PVoid) &disconnect_provider_ultimatum_pdu,
										DOMAIN_MCS_PDU,
										Upward_Connection,
										&packet_error);

			if (disconnect_packet != NULL)
			{
				if (packet_error == PACKET_NO_ERROR)
				{
					/*
					 *	Lock the encoded PDU data and queue the packet up for
					 *	transmission through the transport interface.
					 */
					QueueForTransmission ((PSimplePacket) disconnect_packet,
											TOP_PRIORITY);
					
					/*
					 *	Attempt to flush the message queue.  Since this is the
					 *	object destructor, this is the last chance we will get to
					 *	send queued up PDUs (including the disconnect PDU that we
					 *	just put there).
					 */
					FlushMessageQueue ();
				}
				disconnect_packet->Unlock ();
			}
		} // Domain_Traffic_Allowed == TRUE

		/*
		 *	Issue a disconnect request to the top priority transport connection,
		 *	telling it to wait until the disconnect provider ultimatum has
		 *	cleared the transmitter.
		 */
		ASSERT(g_Transport != NULL);
		g_Transport->DisconnectRequest (Transport_Connection[TOP_PRIORITY]);
		Transport_Connection_State[TOP_PRIORITY] =
				TRANSPORT_CONNECTION_UNASSIGNED;
	}

	/*
	 *	Clear the transmission queue and free any allocated memory.
	 */
	for (priority = 0; priority < MAXIMUM_PRIORITIES; priority++)
	{
		/*
		 *	If we are holding a valid connection handle for this priority, then
		 *	it is necessary to issue a disconnect.
		 */
		if (Transport_Connection_State[priority] !=
				TRANSPORT_CONNECTION_UNASSIGNED)
		{
			ASSERT(g_Transport != NULL);
			g_Transport->DisconnectRequest (
					Transport_Connection[priority]);
		}

		/*
		 *	If there are any remaining data units in the queue for this
		 *	priority, walk through the list releasing all memory associated
		 *	with them.
		 */
		while (NULL != (packet = m_OutPktQueue[priority].Get()))
		{
			packet->Unlock();
		}
	}

	/*
	 *	If there is a memory block holding the user data field of a pending
	 *	connect provider confirm, then free it.
	 */
	FreeMemory (Connect_Response_Memory);

	delete m_pszCalledAddress;
}

/*
 *	void	RegisterTransportConnection ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called in order to register the transport connection
 *		with the connection object.
 */
void Connection::RegisterTransportConnection (
						TransportConnection	transport_connection,
						Priority			priority)
{
	TransportError		transport_error;

	/*
	 *	Make sure that the specified priority is one of those outstanding.
	 */
	if (Transport_Connection_State[priority] != TRANSPORT_CONNECTION_READY)
	{
		/*
		 *	Register this connection object as the owner of the new
		 *	transport connection.
		 */
		transport_error = AcceptTransportConnection (transport_connection,
				priority);

		if (transport_error == TRANSPORT_NO_ERROR)
		{
			TRACE_OUT (("Connection::RegisterTransportConnection: "
					"transport connection accepted"));

			/*
			 *	Check to see if this completes the list of transport
			 *	connections that will be used in this MCS connection.
			 */
			if (Transport_Connection_Count == Domain_Parameters.number_priorities)
			{
				/*
				 *	There are no more transport connections to accept.  We must
				 *	now assign the lowest priority TC to all unassigned
				 *	priorities.
				 */
				AssignRemainingTransportConnections ();
			}
		}
		else
		{
			/*
			 *	The transport connection must be invalid or already assigned
			 *	to another connection object.  We therefore cannot use it.
			 */
			ERROR_OUT (("Connection::RegisterTransportConnection: "
					"register transport connection failed"));
		}
	}
	else
	{
		/*
		 *	A transport connection is not pending for this priority level.
		 *	Reject the registration.
		 */
		ERROR_OUT (("Connection::RegisterTransportConnection: "
				"priority already assigned"));
	}
}

/*
 *	Void	ConnectInitial ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called by the domain when a connection is being created.
 *		It places the necessary domain information into a data packet and
 *		queues the data to be transmitted through the transport interface.
 *
 *	Caveats:
 *		None.
 */
// LONCHANC: we send out calling and called domain selectors but
// at the receiver side, we ignore them completely.
Void	Connection::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)
{
	ConnectMCSPDU		connect_initial_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	connect_initial_pdu.choice = CONNECT_INITIAL_CHOSEN;
	connect_initial_pdu.u.connect_initial.calling_domain_selector.length = sizeof(GCCConfID);
	connect_initial_pdu.u.connect_initial.calling_domain_selector.value = (LPBYTE) calling_domain;
	connect_initial_pdu.u.connect_initial.called_domain_selector.length = sizeof(GCCConfID);
	connect_initial_pdu.u.connect_initial.called_domain_selector.value = (LPBYTE) called_domain;

	connect_initial_pdu.u.connect_initial.upward_flag = (ASN1bool_t)upward_connection;

	memcpy (&(connect_initial_pdu.u.connect_initial.target_parameters),
			domain_parameters, sizeof (PDUDomainParameters));

	memcpy (&(connect_initial_pdu.u.connect_initial.minimum_parameters),
			min_domain_parameters, sizeof(PDUDomainParameters));
	
	memcpy (&(connect_initial_pdu.u.connect_initial.maximum_parameters),
			max_domain_parameters, sizeof(PDUDomainParameters));

	connect_initial_pdu.u.connect_initial.user_data.length = user_data_length;
	connect_initial_pdu.u.connect_initial.user_data.value =	user_data;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &connect_initial_pdu, CONNECT_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	ConnectResponse ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called when issuing a response to a	 "ConnectInitial"
 *		PDU.  The result of the attempted connection, the connection ID, the
 *		domain parameters, and any user data are all put into the packet and
 *		queued for transmission through the transport interface.  If the result
 *		of the attempted connection is negative, the controller and transport
 *		interface are notified.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ConnectResponse (
				Result				result,
				PDomainParameters	domain_parameters,
				ConnectID			connect_id,
				PUChar				user_data,
				ULong				user_data_length)
{
	ConnectMCSPDU		connect_response_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	connect_response_pdu.choice = CONNECT_RESPONSE_CHOSEN;
	connect_response_pdu.u.connect_response.result = (PDUResult)result;
	connect_response_pdu.u.connect_response.called_connect_id = connect_id;
	
	memcpy (&(connect_response_pdu.u.connect_response.domain_parameters),
			domain_parameters, sizeof(PDUDomainParameters));

	connect_response_pdu.u.connect_response.user_data.length = user_data_length;
	connect_response_pdu.u.connect_response.user_data.value = user_data;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &connect_response_pdu, CONNECT_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	ConnectAdditional ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called after successfully processing a"ConnectResponse"
 *		PDU in order to create any addition necessary transport connections.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ConnectAdditional (
				ConnectID			connect_id,
				Priority			priority)
{
	ConnectMCSPDU		connect_additional_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	connect_additional_pdu.choice = CONNECT_ADDITIONAL_CHOSEN;
	connect_additional_pdu.u.connect_additional.called_connect_id = connect_id;
	connect_additional_pdu.u.connect_additional.data_priority =
			(PDUPriority)priority;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &connect_additional_pdu, CONNECT_MCS_PDU, priority);
}

/*
 *	Void	ConnectResult ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called indirectly when issuing a positive response
 *		to a "ConnectAdditional" PDU.  The "ConnectAdditional" PDUs are
 *		processed by the controller and therefore any negative
 *		"ConnectResult" PDU will be issued by the controller.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ConnectResult (
				Result				result,
				Priority			priority)
{
	ConnectMCSPDU		connect_result_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	connect_result_pdu.choice = CONNECT_RESULT_CHOSEN;
	connect_result_pdu.u.connect_result.result = (PDUResult)result;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &connect_result_pdu, CONNECT_MCS_PDU, priority);
}

/*
 *	ULong	ProcessConnectResponse()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine processes the "ConnectResponse" PDU's being received
 *		through the transport interface.  The result of the connection attempt,
 *		the connection ID, and the domain parameters are read from the packet
 *		and the domain notified of the connection response.
 *
 *	Caveats:
 *		None.
 */
ULong	Connection::ProcessConnectResponse (PConnectResponsePDU	pdu_structure)
{
	TransportError		return_value=TRANSPORT_NO_ERROR;
	UINT				priority;
	TransportError		transport_error;

	/*
	 *	Allocate any memory needed to pass user data on to the domain.
	 */
	if (pdu_structure->user_data.length != 0)
	{
		DBG_SAVE_FILE_LINE
		Connect_Response_Memory = AllocateMemory (
				pdu_structure->user_data.value,
				pdu_structure->user_data.length);

		if (Connect_Response_Memory == NULL)
		{
			 ("Connection::ProcessConnectResponse: "
					"memory allocation failed");
			return_value = TRANSPORT_READ_QUEUE_FULL;
		}
	}
	else
		Connect_Response_Memory = NULL;

	/*
	 *	If everything is okay, then process the PDU.  Note that the only way
	 *	for there to be a problem at this point, is if the memory allocation
	 *	above has failed.  If this is the case, returning an error without
	 *	processing the PDU will cause the transport layer to retry the PDU
	 *	at a future time.
	 */
	if (return_value == TRANSPORT_NO_ERROR)
	{
		/*
		 *	Was the connection accepted by the remote side?  If so, then begin
		 *	the process of creating additional TCs (if necessary).
		 */
		if (pdu_structure->result == RESULT_SUCCESSFUL)
		{
			/*
			 *	Get the domain parameters that are to be used for this MCS
			 *	connection.
			 */
			memcpy (&Domain_Parameters, &(pdu_structure->domain_parameters),
					sizeof(PDUDomainParameters));

			/*
			 *	Now that we know what the domain parameters will be for this
			 *	connection, we can determine what type of encoding rules will
			 *	be used for domain PDUs (basic or packed).
			 *	NOTE: The Teles ASN.1 coder assumes the use of packed encoding rules.
			 */
			ASSERT (Domain_Parameters.protocol_version != PROTOCOL_VERSION_BASIC);
			TRACE_OUT (("Connection::ProcessConnectResponse: "
						"using packed encoding rules"));
			Encoding_Rules = PACKED_ENCODING_RULES;

			/*
			 *	Increment the number of transport connections that are now ready
			 *	for domain MCSPDU traffic.
			 */
			Transport_Connection_Count++;

			/*
			 *	If there is at least one additional TC required, then it is
			 *	necessary to create it before this connection can be bound to
			 *	the local domain.
			 */
			if (Transport_Connection_Count < Domain_Parameters.number_priorities)
			{
				/*
				 *	Loop through, creating the proper number of additional
				 *	transport connections.
				 */
				for (priority = Transport_Connection_Count;
						priority < Domain_Parameters.number_priorities;
						priority++)
				{
					/*
					 *	Attempt to create an outbound transport connection.
					 */
					transport_error = CreateTransportConnection (m_pszCalledAddress,
							m_fSecure,
							(Priority) priority);

					if (transport_error == TRANSPORT_NO_ERROR)
					{
						/*
						 *	If we were able to successfully request a new TC,
						 *	then queue up a connect additional, which will
						 *	automatically be sent when the TC becomes valid.
						 */
						ConnectAdditional (
								(UShort) pdu_structure->called_connect_id,
								(Priority) priority);
					}
					else
					{
						/*
						 *	If we were not able to create one of the required
						 *	TCs, then this MCS connection is invalid.  Issue
						 *	a failed connect provider confirm.
						 */
						IssueConnectProviderConfirm (
								RESULT_UNSPECIFIED_FAILURE);

						/*
						 *	Its pointless to try and create any more TCs, so
						 *	break out of this loop.
						 */
						break;
					}
				}
			}
			else
			{
				/*
				 *	If there are no more TCs to create, then copy the lowest
				 *	priority TC into all unassigned priorities.
				 */
				AssignRemainingTransportConnections ();

				/*
				 *	Bind this MCS connection to the domain, now that it is
				 *	ready for use.
				 */
				TRACE_OUT (("Connection::ProcessConnectResponse: "
						"binding MCS connection to domain"));
				m_pDomain = m_pPendingDomain;
				m_pDomain->BindConnAttmnt(this, Upward_Connection, &Domain_Parameters);

				/*
				 *	Issue a successful connect provider confirm to the node
				 *	controller.
				 */
				IssueConnectProviderConfirm (RESULT_SUCCESSFUL);
			}
		}
		else
		{
			/*
			 *	This connection was rejected by the remote side.  It is
			 *	therefore necessary to issue a failed connect provider confirm.
			 */
			IssueConnectProviderConfirm ((Result)pdu_structure->result);
		}
	}

	return ((ULong) return_value);
}

/*
 *	Void	ProcessConnectResult ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine processes "Connect Result" PDU's coming from the
 *		transport interface.  For successful "Connect Result" PDU's this
 *		connection is bound to the domain and a positive Connect Provider
 *		Confirm issued to the controller.  If unsuccessful, a negative
 *		Connect Provider Confirm is issued to the controller.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ProcessConnectResult (PConnectResultPDU		pdu_structure)
{
	Result				result;

	result = (Result)pdu_structure->result;

	/*
	 *	Was the transport connection accepted by the remote system?
	 */
	if (result == RESULT_SUCCESSFUL)
	{
		/*
		 *	Increment the number of transport connections that are now ready
		 *	for domain MCSPDU traffic.
		 */
		Transport_Connection_Count++;

		/*
		 *	Do we now have all transport connections accounted for?
		 */
		if (Transport_Connection_Count == Domain_Parameters.number_priorities)
		{
			/*
			 *	If there are no more TCs to create, then copy the lowest
			 *	priority TC into all unassigned priorities.
			 */
			AssignRemainingTransportConnections ();

			/*
			 *	Bind this MCS connection to the domain, now that it is
			 *	ready for use.
			 */
			TRACE_OUT (("Connection::ProcessConnectResult: "
					"binding MCS connection to domain"));
			m_pDomain = m_pPendingDomain;
			m_pDomain->BindConnAttmnt(this, Upward_Connection, &Domain_Parameters);

			/*
			 *	Issue a successful connect provider confirm to the node
			 *	controller.
			 */
			IssueConnectProviderConfirm (RESULT_SUCCESSFUL);
		}
	}
	else
	{
		/*
		 *	This connection was rejected by the remote side.  It is
		 *	therefore necessary to issue a failed connect provider confirm.
		 */
		IssueConnectProviderConfirm (result);
	}
}

/*
 *	Void	IssueConnectProviderConfirm ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to send a "Connect Provider Confirm"
 *		to the controller through a callback.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::IssueConnectProviderConfirm (
				Result				result)
{
	ConnectConfirmInfo		connect_confirm_info;

	/*
	 *	Make sure there is a confirm pending before issuing one to the
	 *	controller.
	 */
	if (Connect_Provider_Confirm_Pending)
	{
		/*
		 *	Pack the information into the structure for passing in the owner
		 *	callback.
		 */
		ASSERT (g_Transport != NULL);
		connect_confirm_info.domain_parameters = &Domain_Parameters;
		connect_confirm_info.result = result;
		connect_confirm_info.memory = Connect_Response_Memory;

		/*
		 *	Issue the callback to the controller.
		 */
		TRACE_OUT (("Connection::IssueConnectProviderConfirm: "
				"sending CONNECT_PROVIDER_CONFIRM"));
		g_pMCSController->HandleConnConnectProviderConfirm(&connect_confirm_info, Connection_Handle);

		/*
		 *	If there was user data associated with this confirm, free the memory
		 *	block that contained it.
		 */
		if (Connect_Response_Memory != NULL)
		{
			FreeMemory (Connect_Response_Memory);
			Connect_Response_Memory = NULL;
		}

		/*
		 *	Reset the confirm pending flag, to prevent this object from sending
		 *	a second confirm to the controller.
		 */
		Connect_Provider_Confirm_Pending = FALSE;
	}
}

/*
 *	Void	DestroyConnection ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to delete this connection because it has
 *		become invalid.  This is done by issuing a failed confirm to the
 *		controller or, if no confirm is pending, by issuing a delete connection
 *		to the controller.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::DestroyConnection (
				Reason			reason)
{
	Result  result = RESULT_UNSPECIFIED_FAILURE;
	/*
	 *	Modify the Deletion_Reason to reflect why this connection is being
	 *	destroyed.
	 */
	Deletion_Reason = reason;
	
	/*
	 *	Something catastrophic has occurred, so we must ask the controller to
	 *	delete this object.  There are two possible ways of doing this
	 *	(depending on circumstances).  If a connect provider confirm is still
	 *	pending, then we issue a failed confirm to the controller (who will
	 *	forward it to the node controller and destroy this object).  If there
	 *	is not a confirm pending, then we simply issue a delete connection to
	 *	the controller (who will issue a disconnect provider indication to the
	 *	node controller and destroy this object).
	 */
	if (Connect_Provider_Confirm_Pending)
	{
		/*
		 *	Send the failed confirm to the controller.
		 */
		switch (reason)
	  	{
	  	case REASON_REMOTE_NO_SECURITY :
			result = RESULT_REMOTE_NO_SECURITY;
			break;
	  	case REASON_REMOTE_DOWNLEVEL_SECURITY :
			result = RESULT_REMOTE_DOWNLEVEL_SECURITY;
			break;
	  	case REASON_REMOTE_REQUIRE_SECURITY :
	  		result = RESULT_REMOTE_REQUIRE_SECURITY;
	  		break;
		case REASON_AUTHENTICATION_FAILED :
			result = RESULT_AUTHENTICATION_FAILED;
			break;
	  	default :
			result = RESULT_UNSPECIFIED_FAILURE;
			break;
	  }
	  IssueConnectProviderConfirm (result);
	}
	else
	{
		ASSERT (g_Transport != NULL);

		/*
		 *	Issue a delete connection callback to the controller.  When the
		 *	controller deletes this object, it will correctly disconnect itself
		 *	from the layers above and below, and clean up all outstanding
		 *	resources.
		 */
		TRACE_OUT (("Connection::DestroyConnection: sending DELETE_CONNECTION"));
		g_pMCSController->HandleConnDeleteConnection(Connection_Handle);
	}
}

/*
 *	Void	AssignRemainingTransportConnections ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called when there are no more transport connections to
 *		create in order to copy the lowest priority transport connection into
 *		all unassigned priorities.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::AssignRemainingTransportConnections ()
{
	unsigned int			priority;
	TransportConnection		transport_connection;

	/*
	 *	Verify that this MCS connection is in the initializing state before
	 *	proceeding with this request.
	 */
	if (Transport_Connection_State[TOP_PRIORITY] == TRANSPORT_CONNECTION_READY)
	{
		/*
		 *	Loop through for each priority, copying transport connections from
		 *	higher priorities into lower priorities that do not have a
		 *	transport connection assigned.
		 */
		for (priority=0; priority < MAXIMUM_PRIORITIES; priority++)
		{
			if (Transport_Connection_State[priority] ==
					TRANSPORT_CONNECTION_READY)
				transport_connection = Transport_Connection[priority];
			else
			{
				Transport_Connection[priority] = transport_connection;
				Transport_Connection_PDU_Type[priority] = DOMAIN_MCS_PDU;
				Transport_Connection_State[priority] =
						TRANSPORT_CONNECTION_READY;
			}
		}

		/*
		 *	Set the flag indicating that the transmission of domain PDUs is
		 *	now permitted on this MCS connection. Also, flush any queued msgs
		 *	in case they were prevented earlier.
		 *	bugbug: the FlushMessageQueue may fail.
		 */
		Domain_Traffic_Allowed = TRUE;
		FlushMessageQueue ();
	}
	else
	{
		/*
		 *	We have no valid transport connections.  It is therefore not
		 *	possible to bind to the domain.
		 */
		WARNING_OUT (("Connection::AssignRemainingTransportConnections: "
				"no valid transport connections"));
	}
}

/*
 *	TransportError	CreateTransportConnection ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to create new transport connections.
 *
 *	Caveats:
 *		None.
 */
TransportError	Connection::CreateTransportConnection (
						LPCTSTR			called_address,
						BOOL			fSecure,
						Priority		priority)
{
	TransportConnection	transport_connection;
	TransportError		transport_error;

	/*
	 *	Send a connect request to the transport layer to create the transport
	 *	connection.
	 */
	ASSERT(g_Transport != NULL);
	transport_error = g_Transport->ConnectRequest (
			(PChar) called_address, fSecure, priority < MEDIUM_PRIORITY, this,
			&transport_connection);

	if (transport_error == TRANSPORT_NO_ERROR)
	{
		/*
		 *	Mark the transport connection as pending, which indicates that
		 *	it has been assigned, but is not yet ready for use.  This will
		 *	be set to ready when a successsful confirm is received from the
		 *	transport layer.
		 */
		Transport_Connection[priority] = transport_connection;
		Transport_Connection_PDU_Type[priority] = CONNECT_MCS_PDU;
		Transport_Connection_State[priority] = TRANSPORT_CONNECTION_PENDING;
	}
	else
	{
		/*
		 *	The call to the transport layer failed.  Report the error to the
		 *	diagnostic window, and let the error fall through.
		 */
		WARNING_OUT (("Connection::CreateTransportConnection: "
				"connect request failed"));
	}

	return (transport_error);
}

/*
 *	TransportError	AcceptTransportConnection ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to register this connection object
 *		with the transport interface.
 *
 *	Caveats:
 *		None.
 */
TransportError	Connection::AcceptTransportConnection (
						TransportConnection		transport_connection,
						Priority				priority)
{
	TransportError		transport_error;

	/*
	 *	Attempt to register this object with the transport interface.  If
	 *	successful, all indications associated with this transport connection
	 *	will be sent directly to this object.
	 */
	ASSERT(g_Transport != NULL);
	transport_error = g_Transport->RegisterTransportConnection (
			transport_connection, this, priority < MEDIUM_PRIORITY);

	if (transport_error == TRANSPORT_NO_ERROR)
	{
		/*
		 *	Save the transport connection handle that we are supposed to use
		 *	for top priority data transfer.  Also, since this is an inbound
		 *	request, the top priority transport connection IS valid.  Mark
		 *	it as such, allowing data transfer to occur immediately.
		 */
		Transport_Connection[priority] = transport_connection;
		Transport_Connection_PDU_Type[priority] = DOMAIN_MCS_PDU;
		Transport_Connection_State[priority] = TRANSPORT_CONNECTION_READY;
		Transport_Connection_Count++;
	}
	else
	{
		/*
		 *	The call to the transport layer failed.  Report the error to the
		 *	diagnostic window, and let the error fall through.
		 */
		WARNING_OUT (("Connection::AcceptTransportConnection: "
				"invalid transport connection"));
	}

	return (transport_error);
}

/*
 *	Void	AdjustDomainParameters ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to adjust the domain parameters so that
 *		they fall within the allowable range.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::AdjustDomainParameters (
				PDomainParameters	min_domain_parameters,
				PDomainParameters	max_domain_parameters,
				PDomainParameters	domain_parameters)
{
	/*
	 *	Adjust the maximum number of channels to fall within the range.
	 */
	if (domain_parameters->max_channel_ids <
			min_domain_parameters->max_channel_ids)
		domain_parameters->max_channel_ids =
			min_domain_parameters->max_channel_ids;
	else if (domain_parameters->max_channel_ids >
			max_domain_parameters->max_channel_ids)
		domain_parameters->max_channel_ids =
			max_domain_parameters->max_channel_ids;

	/*
	 *	Adjust the maximum number of users to fall within the range.
	 */
	if (domain_parameters->max_user_ids <
			min_domain_parameters->max_user_ids)
		domain_parameters->max_user_ids =
			min_domain_parameters->max_user_ids;
	else if (domain_parameters->max_user_ids >
			max_domain_parameters->max_user_ids)
		domain_parameters->max_user_ids =
			max_domain_parameters->max_user_ids;

	/*
	 *	Adjust the maximum number of tokens to fall within the range.
	 */
	if (domain_parameters->max_token_ids <
			min_domain_parameters->max_token_ids)
		domain_parameters->max_token_ids =
			min_domain_parameters->max_token_ids;
	else if (domain_parameters->max_token_ids >
			max_domain_parameters->max_token_ids)
		domain_parameters->max_token_ids =
			max_domain_parameters->max_token_ids;

	/*
	 *	Adjust the number of priorities to fall within the range.
	 */
	if (domain_parameters->number_priorities <
			min_domain_parameters->number_priorities)
		domain_parameters->number_priorities =
			min_domain_parameters->number_priorities;
	else if (domain_parameters->number_priorities >
			max_domain_parameters->number_priorities)
		domain_parameters->number_priorities =
			max_domain_parameters->number_priorities;

	/*
	 *	Adjust the minimum throughput to fall within the range.
	 */
	if (domain_parameters->min_throughput <
			min_domain_parameters->min_throughput)
		domain_parameters->min_throughput =
			min_domain_parameters->min_throughput;
	else if (domain_parameters->min_throughput >
			max_domain_parameters->min_throughput)
		domain_parameters->min_throughput =
			max_domain_parameters->min_throughput;

	/*
	 *	Adjust the maximum domain height to fall within the range.
	 */
	if (domain_parameters->max_height <
			min_domain_parameters->max_height)
		domain_parameters->max_height =
			min_domain_parameters->max_height;
	else if (domain_parameters->max_height >
			max_domain_parameters->max_height)
		domain_parameters->max_height =
			max_domain_parameters->max_height;

	/*
	 *	Adjust the maximum PDU size to fall within the range.
	 */
	if (domain_parameters->max_mcspdu_size <
			min_domain_parameters->max_mcspdu_size)
		domain_parameters->max_mcspdu_size =
			min_domain_parameters->max_mcspdu_size;
	else if (domain_parameters->max_mcspdu_size >
			max_domain_parameters->max_mcspdu_size)
		domain_parameters->max_mcspdu_size =
			max_domain_parameters->max_mcspdu_size;

	/*
	 *	Adjust the protocol version to fall within the range.
	 */
	if (domain_parameters->protocol_version <
			min_domain_parameters->protocol_version)
		domain_parameters->protocol_version =
			min_domain_parameters->protocol_version;
	else if (domain_parameters->protocol_version >
			max_domain_parameters->protocol_version)
		domain_parameters->protocol_version =
			max_domain_parameters->protocol_version;
}

/*
 *	BOOL    MergeDomainParameters ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to calculate the optimum overlap
 *		between the local and remote domain parameters.  If there is no overlap,
 *		this routine will return a value causing this connection to be
 *		destroyed.
 *
 *	Caveats:
 *		None.
 */
BOOL    Connection::MergeDomainParameters (
				PDomainParameters	min_domain_parameters1,
				PDomainParameters	max_domain_parameters1,
				PDomainParameters	min_domain_parameters2,
				PDomainParameters	max_domain_parameters2)
{
	BOOL    	valid=TRUE;

	/*
	 *	Determine the overlap for maximum number of channels.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->max_channel_ids <
			min_domain_parameters1->max_channel_ids)
		min_domain_parameters2->max_channel_ids =
			min_domain_parameters1->max_channel_ids;
	if (max_domain_parameters2->max_channel_ids >
			max_domain_parameters1->max_channel_ids)
		max_domain_parameters2->max_channel_ids =
			max_domain_parameters1->max_channel_ids;
	if (min_domain_parameters2->max_channel_ids >
			max_domain_parameters2->max_channel_ids)
		valid = FALSE;

	/*
	 *	Determine the overlap for maximum number of users.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->max_user_ids <
			min_domain_parameters1->max_user_ids)
		min_domain_parameters2->max_user_ids =
			min_domain_parameters1->max_user_ids;
	if (max_domain_parameters2->max_user_ids >
			max_domain_parameters1->max_user_ids)
		max_domain_parameters2->max_user_ids =
			max_domain_parameters1->max_user_ids;
	if (min_domain_parameters2->max_user_ids >
			max_domain_parameters2->max_user_ids)
		valid = FALSE;

	/*
	 *	Determine the overlap for maximum number of tokens.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->max_token_ids <
			min_domain_parameters1->max_token_ids)
		min_domain_parameters2->max_token_ids =
			min_domain_parameters1->max_token_ids;
	if (max_domain_parameters2->max_token_ids >
			max_domain_parameters1->max_token_ids)
		max_domain_parameters2->max_token_ids =
			max_domain_parameters1->max_token_ids;
	if (min_domain_parameters2->max_token_ids >
			max_domain_parameters2->max_token_ids)
		valid = FALSE;

	/*
	 *	Determine the overlap for number of priorities.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->number_priorities <
			min_domain_parameters1->number_priorities)
		min_domain_parameters2->number_priorities =
			min_domain_parameters1->number_priorities;
	if (max_domain_parameters2->number_priorities >
			max_domain_parameters1->number_priorities)
		max_domain_parameters2->number_priorities =
			max_domain_parameters1->number_priorities;
	if (min_domain_parameters2->number_priorities >
			max_domain_parameters2->number_priorities)
		valid = FALSE;

	/*
	 *	Determine the overlap for minimum throughput.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->min_throughput <
			min_domain_parameters1->min_throughput)
		min_domain_parameters2->min_throughput =
			min_domain_parameters1->min_throughput;
	if (max_domain_parameters2->min_throughput >
			max_domain_parameters1->min_throughput)
		max_domain_parameters2->min_throughput =
			max_domain_parameters1->min_throughput;
	if (min_domain_parameters2->min_throughput >
			max_domain_parameters2->min_throughput)
		valid = FALSE;

	/*
	 *	Determine the overlap for maximum domain height.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->max_height <
			min_domain_parameters1->max_height)
		min_domain_parameters2->max_height =
			min_domain_parameters1->max_height;
	if (max_domain_parameters2->max_height >
			max_domain_parameters1->max_height)
		max_domain_parameters2->max_height =
			max_domain_parameters1->max_height;
	if (min_domain_parameters2->max_height >
			max_domain_parameters2->max_height)
		valid = FALSE;

	/*
	 *	Determine the overlap for maximum PDU size.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->max_mcspdu_size <
			min_domain_parameters1->max_mcspdu_size)
		min_domain_parameters2->max_mcspdu_size =
			min_domain_parameters1->max_mcspdu_size;
	if (max_domain_parameters2->max_mcspdu_size >
			max_domain_parameters1->max_mcspdu_size)
		max_domain_parameters2->max_mcspdu_size =
			max_domain_parameters1->max_mcspdu_size;
	if (min_domain_parameters2->max_mcspdu_size >
			max_domain_parameters2->max_mcspdu_size)
		valid = FALSE;

	/*
	 *	Determine the overlap for protocol version.  If there is no
	 *	overlap, set the valid flag to FALSE.
	 */
	if (min_domain_parameters2->protocol_version <
			min_domain_parameters1->protocol_version)
		min_domain_parameters2->protocol_version =
			min_domain_parameters1->protocol_version;
	if (max_domain_parameters2->protocol_version >
			max_domain_parameters1->protocol_version)
		max_domain_parameters2->protocol_version =
			max_domain_parameters1->protocol_version;
	if (min_domain_parameters2->protocol_version >
			max_domain_parameters2->protocol_version)
		valid = FALSE;

	return (valid);
}

/*
 *	Void	PrintDomainParameters ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is used for debug purposes in order to print out the
 *		current set of domain parameters.
 *
 *	Caveats:
 *		None.
 */
#ifdef	DEBUG
Void	Connection::PrintDomainParameters (
				PDomainParameters	domain_parameters)
{
	TRACE_OUT (("    Maximum Channels = %ld",
			(ULong) domain_parameters->max_channel_ids));
	TRACE_OUT (("    Maximum Users = %ld",
			(ULong) domain_parameters->max_user_ids));
	TRACE_OUT (("    Maximum Tokens = %ld",
			(ULong) domain_parameters->max_token_ids));
	TRACE_OUT (("    Number of Priorities = %ld",
			(ULong) domain_parameters->number_priorities));
	TRACE_OUT (("    Minimum Throughput = %ld",
			(ULong) domain_parameters->min_throughput));
	TRACE_OUT (("    Maximum Domain Height = %ld",
			(ULong) domain_parameters->max_height));
	TRACE_OUT (("    Maximum PDU Size = %ld",
			(ULong) domain_parameters->max_mcspdu_size));
	TRACE_OUT (("    Protocol Version = %ld",
			(ULong) domain_parameters->protocol_version));
}
#endif // DEBUG


/*
 *	Void	PlumbDomainIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"PlumbDomainIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::PlumbDomainIndication (
				ULong			height_limit)
{
	DomainMCSPDU		plumb_domain_indication_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	plumb_domain_indication_pdu.choice = PLUMB_DOMAIN_INDICATION_CHOSEN;
	plumb_domain_indication_pdu.u.plumb_domain_indication.height_limit =
			height_limit;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &plumb_domain_indication_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ErectDomainRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ErectDomainRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ErectDomainRequest (
				ULong			height_in_domain,
				ULong			throughput_interval)
{
	DomainMCSPDU		erect_domain_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	erect_domain_request_pdu.choice = ERECT_DOMAIN_REQUEST_CHOSEN;
	erect_domain_request_pdu.u.erect_domain_request.sub_height =
			height_in_domain;
	erect_domain_request_pdu.u.erect_domain_request.sub_interval =
			throughput_interval;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &erect_domain_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	RejectUltimatum ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"RejectUltimatum" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::RejectUltimatum (
				Diagnostic		diagnostic,
				PUChar			octet_string_address,
				ULong			octet_string_length)
{
	DomainMCSPDU		reject_ultimatum_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	reject_ultimatum_pdu.choice = REJECT_ULTIMATUM_CHOSEN;
	reject_ultimatum_pdu.u.reject_user_ultimatum.diagnostic = diagnostic;
	reject_ultimatum_pdu.u.reject_user_ultimatum.initial_octets.length =
			(UShort) octet_string_length;
	reject_ultimatum_pdu.u.reject_user_ultimatum.initial_octets.value =
			octet_string_address;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &reject_ultimatum_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	MergeChannelsRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"MergeChannelsRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::MergeChannelsRequest (
				CChannelAttributesList *merge_channel_list,
				CChannelIDList         *purge_channel_list)
{
	MergeChannelsRC (MERGE_CHANNELS_REQUEST_CHOSEN, merge_channel_list, purge_channel_list);
}


/*
 *	Void	MergeChannelsConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"MergeChannelsConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::MergeChannelsConfirm (
				CChannelAttributesList *merge_channel_list,
				CChannelIDList         *purge_channel_list)
{
	MergeChannelsRC (MERGE_CHANNELS_CONFIRM_CHOSEN, merge_channel_list, purge_channel_list);
}


/*
 *	Void	MergeChannelsRC ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"MergeChannelsRequest" or a "MergeChannelsConfirm" PDU
 *		through the transport interface.
 *
 *	IMPORTANT:
 *		Since the code is used for both PDUs the DomainMCSPDU's
 *		merge_channels_request and merge_channels_confirm fields should
 *		be identical structures.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::MergeChannelsRC (
				ASN1choice_t			choice,
				CChannelAttributesList *merge_channel_list,
				CChannelIDList         *purge_channel_list)
{

	BOOL    					memory_error = FALSE;
	DomainMCSPDU				merge_channels_pdu;
	DWORD						channel_attributes_count;
	PSetOfPDUChannelAttributes	setof_channel_attributes;
	PChannelAttributes			channel_attributes;
	PSetOfUserIDs				user_ids_pointer;
	DWORD						purge_channel_count;
	PSetOfChannelIDs			channel_ids_pointer;
	DWORD						dwMemoryToAlloc;
	CUidList                   *user_admit_list;

	/*
	 *	Set the type of PDU to be encoded.
	 */
	merge_channels_pdu.choice = choice;

	/*
	 *	Determine how many channel attributes entries there are in the lists.
	 *	If there are any entries, allocate memory to hold the associated
	 *	structures.
	 */
	channel_attributes_count = merge_channel_list->GetCount();
	purge_channel_count = purge_channel_list->GetCount();

	if ((channel_attributes_count != 0) || (purge_channel_count != 0)) {
		// Determine how much memory we need to allocate
		dwMemoryToAlloc = channel_attributes_count * sizeof (SetOfPDUChannelAttributes) +
							purge_channel_count * sizeof (SetOfChannelIDs);
		merge_channel_list->Reset();
		while (NULL != (channel_attributes = merge_channel_list->Iterate()))
		{
			if (PRIVATE_CHANNEL == channel_attributes->channel_type) {
				dwMemoryToAlloc += sizeof (SetOfUserIDs) *
							(channel_attributes->u.
							private_channel_attributes.admitted_list)->GetCount();
			}
		}

		// Allocate the needed amount of memory.
		DBG_SAVE_FILE_LINE
		setof_channel_attributes = (PSetOfPDUChannelAttributes) Allocate (dwMemoryToAlloc);

		if (setof_channel_attributes == NULL) {
			memory_error = TRUE;
		}
	}
	else {
		setof_channel_attributes = NULL;
	}

	if (setof_channel_attributes == NULL) {
		merge_channels_pdu.u.merge_channels_request.purge_channel_ids = NULL;
		merge_channels_pdu.u.merge_channels_request.merge_channels = NULL;
	}
	else {
		/*
		 *	Get the base address of the array of SetOfChannelIDs structures.
		 */
		channel_ids_pointer = (PSetOfChannelIDs) (((PUChar) setof_channel_attributes) +
					channel_attributes_count * sizeof (SetOfPDUChannelAttributes));
							
		if (channel_attributes_count != 0) {
			/*
			 *	Get the base address of the array of SetOfPDUChannelAttributes
			 *	structures.  Put it into the PDU structure.
			 */
			merge_channels_pdu.u.merge_channels_request.merge_channels =
													setof_channel_attributes;

			/*
			 *	Get the base address of the array of SetOfUserIDs structures.
			 */
			user_ids_pointer = (PSetOfUserIDs) (((PUChar) channel_ids_pointer) +
							purge_channel_count * sizeof (SetOfChannelIDs));

			/*
			 *	Set up an iterator for the list of channel attributes.  Retrieve
			 *	the channel attributes structures from the list and construct the
			 *	PDU structure.
			 */
			merge_channel_list->Reset();
			while (NULL != (channel_attributes = merge_channel_list->Iterate()))
			{
				/*
				 *	Use the channel type to determine what information to include in
				 *	the PDU structure.
				 */
				switch (channel_attributes->channel_type)
				{
					case STATIC_CHANNEL:
						setof_channel_attributes->value.choice =
								CHANNEL_ATTRIBUTES_STATIC_CHOSEN;

						setof_channel_attributes->value.u.
								channel_attributes_static.channel_id =
								channel_attributes->u.
								static_channel_attributes.channel_id;
						break;
	
					case USER_CHANNEL:
						setof_channel_attributes->value.choice =
								CHANNEL_ATTRIBUTES_USER_ID_CHOSEN;

						setof_channel_attributes->value.u.
								channel_attributes_user_id.joined =
								(ASN1bool_t)channel_attributes->u.
								user_channel_attributes.joined;

						setof_channel_attributes->value.u.
								channel_attributes_user_id.user_id =
								channel_attributes->u.
								user_channel_attributes.user_id;
						break;

					case PRIVATE_CHANNEL:
						setof_channel_attributes->value.choice =
								CHANNEL_ATTRIBUTES_PRIVATE_CHOSEN;

						setof_channel_attributes->value.u.
								channel_attributes_private.joined =
								(ASN1bool_t)channel_attributes->u.
								private_channel_attributes.joined;

						setof_channel_attributes->value.u.
								channel_attributes_private.channel_id =
								channel_attributes->u.
								private_channel_attributes.channel_id;

						setof_channel_attributes->value.u.
								channel_attributes_private.manager =
								channel_attributes->u.
								private_channel_attributes.channel_manager;

						/*
						 *	Get the number of the User IDs in the list of user ID's
						 */
						if ((channel_attributes->u.private_channel_attributes.				
											admitted_list)->GetCount() > 0)
						{
							/*
							 *	Get the base address of the array of SetOfUserIDs
							 *	structures.  Put it into the channel attributes
							 *	structure.
							 */
							setof_channel_attributes->value.u.channel_attributes_private.admitted =
														user_ids_pointer;
	
							/*
							 *	Iterate through the set of user ids, filling in the
							 *	PDU structure.
							 */
							user_admit_list = channel_attributes->u.private_channel_attributes.admitted_list;
							user_admit_list->BuildExternalList(&user_ids_pointer);
						}
						else
						{
							/*
							 *	There are either no users admitted to this channel,
							 *	or a memory allocation error occurred above.
							 *	Either way, we need to set the admitted array
							 *	address to NULL.
							 */
							setof_channel_attributes->value.u.
										channel_attributes_private.admitted = NULL;
						}
						break;
	
					case ASSIGNED_CHANNEL:
						setof_channel_attributes->value.choice =
								CHANNEL_ATTRIBUTES_ASSIGNED_CHOSEN;

						setof_channel_attributes->value.u.
								channel_attributes_assigned.channel_id =
								channel_attributes->u.
								assigned_channel_attributes.channel_id;
						break;

					default:
						WARNING_OUT(("Connection::MergeChannelsRC: "
								"ERROR - bad channel type"));
						break;
				}

				/*
				 *	Set the next pointer to point to the next element of the
				 *	PDU channel attributes structure array.  Then increment the
				 *	pointer.
				 */
				setof_channel_attributes->next = setof_channel_attributes + 1;
				setof_channel_attributes++;
			}

			/*
			 *	Decrement the pointer in order to set the last "next" pointer to
			 *	NULL.
			 */
			(setof_channel_attributes - 1)->next = NULL;
		}
		else {
			/*	There are no channels to merge. We need to set the structure
			 *	array address to NULL.
			 */
			merge_channels_pdu.u.merge_channels_request.merge_channels = NULL;
		}

		// Work on the purged channels.
		if (purge_channel_count != 0) {

			/*
			 *	Get the base address of the array of SetOfChannelIDs structures.
			 *	Put it into the PDU structure.
			 */
			merge_channels_pdu.u.merge_channels_request.purge_channel_ids = channel_ids_pointer;
            purge_channel_list->BuildExternalList(&channel_ids_pointer);
		}
		else
		{
			/*
			 *	There are either no channels to purge or a memory allocation
			 *	failure occurred above.  Either way, we need to set the structure
			 *	array address to NULL.
			 */
			merge_channels_pdu.u.merge_channels_request.purge_channel_ids = NULL;
		}
	}

	/*
	 *	Send the packet to the remote provider.
	 */
	if (memory_error == FALSE)
		SendPacket ((PVoid) &merge_channels_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
	else
	{
		/*
		 *	A memory allocation failure occurred somewhere above.  Report the
		 *	error and destroy this faulty connection.
		 */
		ERROR_OUT (("Connection::MergeChannelsRC: memory allocation failure"));
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}

	/*
	 *	Free up the memory block that was allocated to build this PDU
	 *	structure.
	 */
	Free(setof_channel_attributes - channel_attributes_count);
}


/*
 *	Void	PurgeChannelsIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"PurgeChannelsIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::PurgeChannelsIndication (
				CUidList           *purge_user_list,
				CChannelIDList     *purge_channel_list)
{
	BOOL    			memory_error = FALSE;
	DomainMCSPDU		purge_channel_indication_pdu;
	ULong				user_id_count;
	PSetOfUserIDs		user_ids_pointer;
	DWORD				purge_channel_count;
	PSetOfChannelIDs	channel_ids_pointer;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	purge_channel_indication_pdu.choice = PURGE_CHANNEL_INDICATION_CHOSEN;
	
	/*
	 *	Allocate memory to hold the list of user ID's and the list
	 *	of purged channels.  If the allocation
	 *	fails, set the flag which will result in a callback to the
	 *	controller requesting that this connection be deleted.
	 */
	user_id_count = purge_user_list->GetCount();
	purge_channel_count = purge_channel_list->GetCount();

	if (user_id_count != 0 || purge_channel_count != 0)
	{
		DBG_SAVE_FILE_LINE
		user_ids_pointer = (PSetOfUserIDs) Allocate (user_id_count * sizeof (SetOfUserIDs) +
											purge_channel_count * sizeof (SetOfChannelIDs));

		if (user_ids_pointer == NULL) {
			memory_error = TRUE;
		}
	}
	else
		user_ids_pointer = NULL;

	if (user_ids_pointer == NULL) {
		purge_channel_indication_pdu.u.purge_channel_indication.detach_user_ids = NULL;
		purge_channel_indication_pdu.u.purge_channel_indication.purge_channel_ids = NULL;
	}
	else {
		if (user_id_count != 0) {
			/*
			 *	Fill in the structure's pointer to the set of user ID's.
			 */
			purge_channel_indication_pdu.u.purge_channel_indication.detach_user_ids = user_ids_pointer;
            purge_user_list->BuildExternalList(&user_ids_pointer);
		}
		else
		{
			/*
			 *	Either there are no user IDs to purge or a memory allocation
			 *	failed above.  Either way, put NULL into the PDU structure to
			 *	indicate that there is no list of IDs.
			 */
			purge_channel_indication_pdu.u.purge_channel_indication.
												detach_user_ids = NULL;
		}

		if (purge_channel_count != 0) {
			/*
			 *	Fill in the structure's pointer to the set of purge channel ID's.
			 */
			channel_ids_pointer = (PSetOfChannelIDs) user_ids_pointer;
			purge_channel_indication_pdu.u.purge_channel_indication.purge_channel_ids = channel_ids_pointer;
            purge_channel_list->BuildExternalList(&channel_ids_pointer);
		}
		else
		{
			/*
			 *	Either there are no channel IDs to purge or a memory allocation
			 *	failed above.  Either way, put NULL into the PDU structure to
			 *	indicate that there is no list of IDs.
			 */
			purge_channel_indication_pdu.u.purge_channel_indication.purge_channel_ids = NULL;
		}
	}

	/*
	 *	Send the packet to the remote provider.
	 */
	if (memory_error == FALSE)
		SendPacket ((PVoid) &purge_channel_indication_pdu, DOMAIN_MCS_PDU,
				TOP_PRIORITY);
	else
	{
		/*
		 *	A memory allocation failure occurred somewhere above.  Report the
		 *	error and destroy this faulty connection.
		 */
		ERROR_OUT (("Connection::PurgeChannelsIndication: "
				"memory allocation failure"));
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}

	/*
	 *	Free all memory allocated above.
	 */
	Free(user_ids_pointer - user_id_count);
}

/*
 *	Void	MergeTokenRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"MergeTokensRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::MergeTokensRequest (
				CTokenAttributesList       *merge_token_list,
				CTokenIDList               *purge_token_list)
{
	MergeTokensRC (MERGE_TOKENS_REQUEST_CHOSEN, merge_token_list, purge_token_list);
}

/*
 *	Void	MergeTokenConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"MergeTokenConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::MergeTokensConfirm (
				CTokenAttributesList       *merge_token_list,
				CTokenIDList               *purge_token_list)
{
	MergeTokensRC (MERGE_TOKENS_CONFIRM_CHOSEN, merge_token_list, purge_token_list);
}


/*
 *	Void	MergeTokenRC ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"MergeTokenConfirm" PDU or a "MergeTokenRequest" PDU through
 *		the transport interface.
 *
 *	IMPORTANT:
 *		Since the code is used for both PDUs the DomainMCSPDU's
 *		merge_tokens_request and merge_tokens_confirm fields should
 *		be identical structures.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::MergeTokensRC (
				ASN1choice_t				choice,
				CTokenAttributesList       *merge_token_list,
				CTokenIDList               *purge_token_list)

{
	BOOL    					memory_error = FALSE;
	DomainMCSPDU				merge_tokens_pdu;
	DWORD						token_attributes_count;
	PSetOfPDUTokenAttributes	setof_token_attributes;
	PTokenAttributes			token_attributes;
	PSetOfUserIDs				user_ids_pointer;
	DWORD						purge_token_count;
	PSetOfTokenIDs				token_ids_pointer;
	DWORD						dwMemoryToAlloc;
	CUidList                   *user_inhibit_list;

	merge_tokens_pdu.choice = choice;

	/*
	 *	Determine how many tokens are being merged with this PDU.  This is
	 *	used to allocate a buffer for big enough for all of the needed token
	 *	attributes structures.
	 */
	token_attributes_count = merge_token_list->GetCount();
	purge_token_count = purge_token_list->GetCount();

	if ((token_attributes_count != 0) || (purge_token_count != 0)) {
		// Determine how much memory we need to allocate
		dwMemoryToAlloc = token_attributes_count * sizeof (SetOfPDUTokenAttributes) +
							purge_token_count * sizeof (SetOfTokenIDs);
		merge_token_list->Reset();
		while (NULL != (token_attributes = merge_token_list->Iterate()))
		{
			if (TOKEN_INHIBITED == token_attributes->token_state) {
				dwMemoryToAlloc += sizeof (SetOfUserIDs) *
							token_attributes->u.inhibited_token_attributes.
							inhibitors->GetCount();
			}
		}

		// Allocate the needed amount of memory.
		DBG_SAVE_FILE_LINE
		setof_token_attributes = (PSetOfPDUTokenAttributes) Allocate (dwMemoryToAlloc);

		if (setof_token_attributes == NULL) {
			memory_error = TRUE;
		}
	}
	else {
		setof_token_attributes = NULL;
	}

	if (setof_token_attributes == NULL) {
		merge_tokens_pdu.u.merge_tokens_confirm.merge_tokens = NULL;
		merge_tokens_pdu.u.merge_tokens_confirm.purge_token_ids = NULL;
	}
	else {

		/*
		 *	Compute where the set of purged token IDs will start from in the
		 *	memory previously allocated.
		 */
		token_ids_pointer = (PSetOfTokenIDs) ((PUChar) setof_token_attributes +
							token_attributes_count * sizeof (SetOfPDUTokenAttributes));

		if (token_attributes_count != 0) {
			/*
			 *	Get the base address of the array of SetOfPDUTokenAttributes
			 *	structures.  Put it into the PDU structure.
			 */
			merge_tokens_pdu.u.merge_tokens_confirm.merge_tokens =
													setof_token_attributes;

			/*
			 *	Compute the base address of the arrays of SetOfUserIDs structures.
			 */
			user_ids_pointer = (PSetOfUserIDs) ((PUChar) token_ids_pointer +
							purge_token_count * sizeof (SetOfTokenIDs));

			/*
			 *	Set up an iterator for the list of token attributes.  Retrieve
			 *	the token attributes structures from the list and construct the
			 *	PDU structure.
			 */
			merge_token_list->Reset();
			while (NULL != (token_attributes = merge_token_list->Iterate()))
			{
				/*
				 *	Use the token state to determine what information to include in
				 *	the PDU structure.
				 */
				switch (token_attributes->token_state)
				{
				case TOKEN_GRABBED:
					setof_token_attributes->value.choice = GRABBED_CHOSEN;

					setof_token_attributes->value.u.grabbed.token_id =
							token_attributes->u.
							grabbed_token_attributes.token_id;
					setof_token_attributes->value.u.grabbed.grabber =
							token_attributes->u.
							grabbed_token_attributes.grabber;
					break;

				case TOKEN_INHIBITED:
					setof_token_attributes->value.choice = INHIBITED_CHOSEN;

					setof_token_attributes->value.u.inhibited.token_id =
							token_attributes->u.
							inhibited_token_attributes.token_id;

					if ((token_attributes->u.inhibited_token_attributes.
											inhibitors)->GetCount() > 0)
					{
						/*
						 *	Get the base address of the array of SetOfUserIDs
						 *	structures.  Put it into the channel attributes
						 *	structure.
						 */
						setof_token_attributes->value.u.inhibited.inhibitors =
								user_ids_pointer;

						/*
						 *	Iterate through the User ID list, adding each user
						 *	to the PDU.
						 */
						user_inhibit_list = token_attributes->u.inhibited_token_attributes.inhibitors;
						user_inhibit_list->BuildExternalList(&user_ids_pointer);
					}
					else
					{
						/*
						 *	Either there were no inhibitors of this token, or
						 *	a memory allocation failure occurred above.  Either
						 *	way, put a NULL into the PDU structure to indicate
						 *	that this field is unused.
						 */
						setof_token_attributes->value.u.inhibited.inhibitors =
								NULL;
					}
					break;

				case TOKEN_GIVING:
					setof_token_attributes->value.choice = GIVING_CHOSEN;

					/*
					 *	IMPORTANT:
					 *	The two structs involved in this memcpy should have
					 *	same-type fields.
					 *	Original code is included below.
					 */
					memcpy (&(setof_token_attributes->value.u.giving),
							&(token_attributes->u.giving_token_attributes),
							sizeof (Giving));
/*
					setof_token_attributes->value.u.giving.token_id =
							token_attributes->u.
							giving_token_attributes.token_id;

					setof_token_attributes->value.u.giving.grabber =
							token_attributes->u.
							giving_token_attributes.grabber;

					setof_token_attributes->value.u.giving.recipient =
							token_attributes->u.
							giving_token_attributes.recipient;
*/
					break;

				case TOKEN_GIVEN:
					setof_token_attributes->value.choice = GIVEN_CHOSEN;

					setof_token_attributes->value.u.given.token_id =
							token_attributes->u.
							given_token_attributes.token_id;

					setof_token_attributes->value.u.given.recipient =
							token_attributes->u.
							given_token_attributes.recipient;
					break;

				default:
					WARNING_OUT(("Connection::MergeTokensRC: bad channel type"));
					break;
				}

				/*
				 *	Set the next pointer to point to the next element of the
				 *	PDU token attributes structure array.  Then increment the
				 *	pointer.
				 */
				setof_token_attributes->next = setof_token_attributes + 1;
				setof_token_attributes++;
			}

			/*
			 *	Decrement the pointer in order to set the last "next" pointer to
			 *	NULL.
			 */
			(setof_token_attributes - 1)->next = NULL;
		}
		else
		{
			/*
			 *	Either there are no tokens to merge, or a memory allocation failure
			 *	occurred above.  Either way put a NULL into the PDU structure to
			 *	indicate that this field is unused.
			 */
			merge_tokens_pdu.u.merge_tokens_confirm.merge_tokens = NULL;
		}

		if (purge_token_count != 0)
		{

			/*
			 *	Fill in the MergeTokensRequest structure's pointer to the set of
			 *	purge token ID's.
			 */
			merge_tokens_pdu.u.merge_tokens_confirm.purge_token_ids = token_ids_pointer;
            purge_token_list->BuildExternalList(&token_ids_pointer);
		}
		else
		{
			/*
			 *	Either there are no tokens to be purged, or a memory allocation
			 *	failure occurred above.  Either way, put a NULL into the PDU
			 *	structure to indicate that this field is unused.
			 */
			merge_tokens_pdu.u.merge_tokens_confirm.purge_token_ids = NULL;
		}
	}

	/*
	 *	Send the packet to the remote provider.
	 */
	if (memory_error == FALSE)
		SendPacket ((PVoid) &merge_tokens_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
	else
	{
		/*
		 *	A memory allocation failure occurred somewhere above.  Report the
		 *	error and destroy this faulty connection.
		 */
		ERROR_OUT (("Connection::MergeTokensRC: memory allocation failure"));
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}

	/*
	 *	Release all memory allocated above.
	 */
	Free(setof_token_attributes - token_attributes_count);
}

/*
 *	Void	PurgeTokensIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"PurgeTokenIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::PurgeTokensIndication (
				PDomain,
				CTokenIDList        *purge_token_list)
{
	BOOL    			memory_error=FALSE;
	DomainMCSPDU		purge_token_indication_pdu;
	DWORD				purge_token_count;
	PSetOfTokenIDs		token_ids_pointer;
    //TokenID             tid;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	purge_token_indication_pdu.choice = PURGE_TOKEN_INDICATION_CHOSEN;
	
	/*
	 *	Allocate memory to hold the list of purge tokens.  If the allocation
	 *	fails, set the flag which will result in a callback to the
	 *	controller requesting that this connection be deleted.
	 */
	purge_token_count = purge_token_list->GetCount();

	if (purge_token_count != 0)
	{
		DBG_SAVE_FILE_LINE
		token_ids_pointer = (PSetOfTokenIDs) Allocate (purge_token_count *
														sizeof (SetOfTokenIDs));

		if (token_ids_pointer == NULL)
			memory_error = TRUE;
	}
	else
		token_ids_pointer = NULL;

	if (token_ids_pointer!= NULL)	
	{
		/*
		 *	Fill in the structure's pointer to the set of purge token ID's.
		 */
		purge_token_indication_pdu.u.purge_token_indication.purge_token_ids = token_ids_pointer;
        purge_token_list->BuildExternalList(&token_ids_pointer);
	}
	else
	{
		/*
		 *	Either there are no tokens to purge or a memory allocation failure
		 *	occurred above.  Either way, put a NULL into the PDU structure to
		 *	indicate that this field is unused.
		 */
		purge_token_indication_pdu.u.purge_token_indication.purge_token_ids = NULL;
	}

	/*
	 *	Send the packet to the remote provider.
	 */
	if (memory_error == FALSE)
		SendPacket ((PVoid) &purge_token_indication_pdu, DOMAIN_MCS_PDU,
				TOP_PRIORITY);
	else
	{
		/*
		 *	A memory allocation failure occurred somewhere above.  Report the
		 *	error and destroy this faulty connection.
		 */
		ERROR_OUT (("Connection::PurgeTokensIndication: memory allocation failure"));
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}

	/*
	 *	If memory was successfully allocated to hold the set of token ID's,
	 *	then free it here.
	 */
	Free(token_ids_pointer - purge_token_count);
}

/*
 *	Void	DisconnectProviderUltimatum ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"DisconnectProviderUltimatum" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::DisconnectProviderUltimatum (
				Reason				reason)
{
	/*
	 *	Set attachment to NULL to prevent any attempt to send a command to
	 *	the attachment that just disconnected us.
	 */
	m_pDomain = NULL;

	/*
	 *	Issue an owner callback to ask for deletion.  An attempt will be made
	 *	to send a DisconnectProviderUltimatum PDU through the transport
	 *	interface from the Connection's destructor.
	 */
	DestroyConnection (reason);
}

/*
 *	Void	AttachUserRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"AttachUserRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::AttachUserRequest ( void )
{
	DomainMCSPDU		attach_user_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	attach_user_request_pdu.choice = ATTACH_USER_REQUEST_CHOSEN;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &attach_user_request_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	AttachUserConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"AttachUserConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::AttachUserConfirm (
				Result				result,
				UserID				uidInitiator)
{
	DomainMCSPDU		attach_user_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	attach_user_confirm_pdu.choice = ATTACH_USER_CONFIRM_CHOSEN;
	if (result == RESULT_SUCCESSFUL)
		attach_user_confirm_pdu.u.attach_user_confirm.bit_mask =
				INITIATOR_PRESENT;
	else
		attach_user_confirm_pdu.u.attach_user_confirm.bit_mask = 0x00;
	attach_user_confirm_pdu.u.attach_user_confirm.result = (PDUResult)result;
	attach_user_confirm_pdu.u.attach_user_confirm.initiator = uidInitiator;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &attach_user_confirm_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	DetachUserRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"DetachUserRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::DetachUserRequest (
				Reason				reason,
				CUidList           *user_id_list)
{
	UserChannelRI (DETACH_USER_REQUEST_CHOSEN, (UINT) reason, 0, user_id_list);
}


/*
 *	Void	UserChannelRI ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"DetachUserRequest", "DetachUserIndication", "ChannelAdmitRequest",
 *		"ChannelAdmitIndication", "ChannelExpelRequest" or
 *		"ChannelExpelIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::UserChannelRI (
				ASN1choice_t		choice,
				UINT				reason_userID,
				ChannelID			channel_id,
				CUidList           *user_id_list)
{
	BOOL    			memory_error = FALSE;
	DomainMCSPDU		domain_pdu;
	DWORD				user_ids_count;
	PSetOfUserIDs		user_ids_pointer;
    //UserID              uid;

	/*
	 *	Allocate memory to hold the list of users.  If the allocation
	 *	fails, set the flag which will result in a callback to the
	 *	controller requesting that this connection be deleted.
	 */
	user_ids_count = user_id_list->GetCount();

	if (user_ids_count != 0)
	{
		DBG_SAVE_FILE_LINE
		user_ids_pointer = (PSetOfUserIDs) Allocate (user_ids_count *
													sizeof (SetOfUserIDs));

		if (user_ids_pointer == NULL)
			memory_error = TRUE;
	}
	else
		user_ids_pointer = NULL;

	/*
	 *	Fill in the PDU structure to be encoded. Also,
	 *	get the base address of the SetOfUserIDs structure and put it into
	 *	the PDU structure.
	 */
	domain_pdu.choice = choice;
	switch (choice) {
		case DETACH_USER_REQUEST_CHOSEN:
		case DETACH_USER_INDICATION_CHOSEN:
			/*
			 *	IMPORTANT:
			 *		The detach_user_request and detach_user_indication structs
			 *		in DomainMCSPDU must be identical.
			 */
			domain_pdu.u.detach_user_request.reason = (PDUReason) reason_userID;
			domain_pdu.u.detach_user_request.user_ids = user_ids_pointer;
			break;

		case CHANNEL_ADMIT_REQUEST_CHOSEN:
		case CHANNEL_ADMIT_INDICATION_CHOSEN:
		case CHANNEL_EXPEL_REQUEST_CHOSEN:
			/*
			 *	IMPORTANT:
			 *		The channel_admit_request, channel_admit_indication
			 *		and channel_expel_request structs
			 *		in DomainMCSPDU must be identical.
			 */
			domain_pdu.u.channel_admit_request.initiator = (UserID) reason_userID;
			domain_pdu.u.channel_admit_request.channel_id = channel_id;
			domain_pdu.u.channel_admit_request.user_ids = user_ids_pointer;
			break;

		case CHANNEL_EXPEL_INDICATION_CHOSEN:
			domain_pdu.u.channel_expel_indication.channel_id = channel_id;
			domain_pdu.u.channel_expel_indication.user_ids = user_ids_pointer;
			break;

		default:
			ASSERT(FALSE);
			ERROR_OUT (("Connection::UserChannelRI: PDU should not be formed by this method."));
			break;
	}

    user_id_list->BuildExternalList(&user_ids_pointer);

	/*
	 *	Send the packet to the remote provider.
	 */
	if (memory_error == FALSE)
		SendPacket ((PVoid) &domain_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
	else
	{
		/*
		 *	A memory allocation failure occurred somewhere above.  Report the
		 *	error and destroy this faulty connection.
		 */
		ERROR_OUT (("Connection::UserChannelRI: memory allocation failure"));
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}

	/*
	 *	If memory was successfully allocated to hold the set of user ID's,
	 *	then free it here.
	 */
	Free(user_ids_pointer - user_ids_count);
}

/*
 *	Void	DetachUserIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"DetachUserIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::DetachUserIndication (
				Reason				reason,
				CUidList           *user_id_list)
{
	UserChannelRI (DETACH_USER_INDICATION_CHOSEN, (UINT) reason, 0, user_id_list);
}


/*
 *	Void	ChannelJoinRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelJoinRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelJoinRequest (
				UserID				uidInitiator,
				ChannelID			channel_id)
{
	DomainMCSPDU		channel_join_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	channel_join_request_pdu.choice = CHANNEL_JOIN_REQUEST_CHOSEN;
	channel_join_request_pdu.u.channel_join_request.initiator = uidInitiator;
	channel_join_request_pdu.u.channel_join_request.channel_id = channel_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &channel_join_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ChannelJoinConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelJoinConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelJoinConfirm (
				Result				result,
				UserID				uidInitiator,
				ChannelID			requested_id,
				ChannelID			channel_id)
{
	DomainMCSPDU		channel_join_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	channel_join_confirm_pdu.choice = CHANNEL_JOIN_CONFIRM_CHOSEN;
	if (result == RESULT_SUCCESSFUL)
		channel_join_confirm_pdu.u.channel_join_confirm.bit_mask =
				JOIN_CHANNEL_ID_PRESENT;
	else
		channel_join_confirm_pdu.u.channel_join_confirm.bit_mask = 0x00;
	channel_join_confirm_pdu.u.channel_join_confirm.result = (PDUResult)result;
	channel_join_confirm_pdu.u.channel_join_confirm.initiator = uidInitiator;
	channel_join_confirm_pdu.u.channel_join_confirm.requested = requested_id;
	channel_join_confirm_pdu.u.channel_join_confirm.join_channel_id =
			channel_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &channel_join_confirm_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ChannelLeaveRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelLeaveRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelLeaveRequest (
				CChannelIDList  *channel_id_list)
{
	BOOL    			memory_error=FALSE;
	DomainMCSPDU		channel_leave_request_pdu;
	DWORD				channel_ids_count;
	PSetOfChannelIDs	channel_ids_pointer;
    PSetOfChannelIDs    pToFree;
    //ChannelID           chid;

	/*
	 *	Fill in the elements of the PDU structure.
	 */
	channel_leave_request_pdu.choice = CHANNEL_LEAVE_REQUEST_CHOSEN;

	/*
	 *	Allocate memory to hold the list of channels.  If the allocation
	 *	fails, set the flag which will result in a callback to the
	 *	controller requesting that this connection be deleted.
	 */
	channel_ids_count = channel_id_list->GetCount();

	if (channel_ids_count != 0)
	{
		DBG_SAVE_FILE_LINE
		channel_ids_pointer = (PSetOfChannelIDs) Allocate (channel_ids_count *
													sizeof (SetOfChannelIDs));
		if (channel_ids_pointer == NULL)
			memory_error = TRUE;
	}
	else
		channel_ids_pointer = NULL;

    pToFree = channel_ids_pointer;

    /*
	 *	Get the base address of the array fo SetOfChannelIDs structure and
	 *	put it into the PDU structure.
	 */
	channel_leave_request_pdu.u.channel_leave_request.channel_ids = channel_ids_pointer;
    channel_id_list->BuildExternalList(&channel_ids_pointer);

	/*
	 *	Send the packet to the remote provider.
	 */
	if (memory_error == FALSE)
		SendPacket ((PVoid) &channel_leave_request_pdu, DOMAIN_MCS_PDU,
				TOP_PRIORITY);
	else
	{
		/*
		 *	A memory allocation failure occurred somewhere above.  Report the
		 *	error and destroy this faulty connection.
		 */
		ERROR_OUT (("Connection::ChannelLeaveRequest: memory allocation failure"));
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}

	/*
	 *	If memory was successfully allocated to hold the set of channel ID's,
	 *	then free it here.
	 */
	Free(pToFree);
}

/*
 *	Void	ChannelConveneRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelConveneRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelConveneRequest (
				UserID				uidInitiator)
{
	DomainMCSPDU		channel_convene_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	channel_convene_request_pdu.choice = CHANNEL_CONVENE_REQUEST_CHOSEN;
	channel_convene_request_pdu.u.channel_convene_request.initiator =
			uidInitiator;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &channel_convene_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ChannelConveneConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelConveneConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelConveneConfirm (
				Result				result,
				UserID				uidInitiator,
				ChannelID			channel_id)
{
	DomainMCSPDU		channel_convene_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	channel_convene_confirm_pdu.choice = CHANNEL_CONVENE_CONFIRM_CHOSEN;
	if (result == RESULT_SUCCESSFUL)
		channel_convene_confirm_pdu.u.channel_convene_confirm.bit_mask =
			CONVENE_CHANNEL_ID_PRESENT;
	else
		channel_convene_confirm_pdu.u.channel_convene_confirm.bit_mask = 0x00;
	channel_convene_confirm_pdu.u.channel_convene_confirm.result =
			(PDUResult)result;
	channel_convene_confirm_pdu.u.channel_convene_confirm.initiator =
			uidInitiator;
	channel_convene_confirm_pdu.u.channel_convene_confirm.convene_channel_id =
			channel_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &channel_convene_confirm_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ChannelDisbandRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelDisbandRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelDisbandRequest (
				UserID				uidInitiator,
				ChannelID			channel_id)
{
	DomainMCSPDU		channel_disband_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	channel_disband_request_pdu.choice = CHANNEL_DISBAND_REQUEST_CHOSEN;
	channel_disband_request_pdu.u.channel_disband_request.initiator =
			uidInitiator;
	channel_disband_request_pdu.u.channel_disband_request.channel_id =
			channel_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &channel_disband_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ChannelDisbandIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelDisbandIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelDisbandIndication (
				ChannelID			channel_id)
{
	DomainMCSPDU		channel_disband_indication_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	channel_disband_indication_pdu.choice = CHANNEL_DISBAND_INDICATION_CHOSEN;
	channel_disband_indication_pdu.u.channel_disband_indication.channel_id =
			channel_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &channel_disband_indication_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	ChannelAdmitRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelAdmitRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelAdmitRequest (
				UserID				uidInitiator,
				ChannelID			channel_id,
				CUidList           *user_id_list)
{
	UserChannelRI (CHANNEL_ADMIT_REQUEST_CHOSEN, (UINT) uidInitiator, channel_id,
					user_id_list);
}

/*
 *	Void	ChannelAdmitIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelAdmitIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelAdmitIndication (
				UserID				uidInitiator,
				ChannelID			channel_id,
				CUidList           *user_id_list)
{
	UserChannelRI (CHANNEL_ADMIT_INDICATION_CHOSEN, (UINT) uidInitiator, channel_id,
					user_id_list);
}

/*
 *	Void	ChannelExpelRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelExpelRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelExpelRequest (
				UserID				uidInitiator,
				ChannelID			channel_id,
				CUidList           *user_id_list)
{
	UserChannelRI (CHANNEL_EXPEL_REQUEST_CHOSEN, (UINT) uidInitiator, channel_id,
					user_id_list);
}

/*
 *	Void	ChannelExpelIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"ChannelExpelIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::ChannelExpelIndication (
				ChannelID			channel_id,
				CUidList           *user_id_list)
{
	UserChannelRI (CHANNEL_EXPEL_INDICATION_CHOSEN, 0, channel_id,
					user_id_list);
}


/*
 *	Void	TokenGrabRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenGrabRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenGrabRequest (
				UserID				uidInitiator,
				TokenID				token_id)
{
	DomainMCSPDU		token_grab_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_grab_request_pdu.choice = TOKEN_GRAB_REQUEST_CHOSEN;
	token_grab_request_pdu.u.token_grab_request.initiator = uidInitiator;
	token_grab_request_pdu.u.token_grab_request.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_grab_request_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	TokenGrabConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenGrabConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenGrabConfirm (
				Result				result,
				UserID				uidInitiator,
				TokenID				token_id,
				TokenStatus			token_status)
{
	DomainMCSPDU		token_grab_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_grab_confirm_pdu.choice = TOKEN_GRAB_CONFIRM_CHOSEN;
	token_grab_confirm_pdu.u.token_grab_confirm.result = (PDUResult)result;
	token_grab_confirm_pdu.u.token_grab_confirm.initiator = uidInitiator;
	token_grab_confirm_pdu.u.token_grab_confirm.token_id = token_id;
	token_grab_confirm_pdu.u.token_grab_confirm.token_status =
			(PDUTokenStatus)token_status;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_grab_confirm_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	TokenInhibitRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenInhibitRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenInhibitRequest (
				UserID				uidInitiator,
				TokenID				token_id)
{
	DomainMCSPDU		token_inhibit_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_inhibit_request_pdu.choice = TOKEN_INHIBIT_REQUEST_CHOSEN;
	token_inhibit_request_pdu.u.token_inhibit_request.initiator = uidInitiator;
	token_inhibit_request_pdu.u.token_inhibit_request.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_inhibit_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenInhibitConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenInhibitConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenInhibitConfirm (
				Result				result,
				UserID				uidInitiator,
				TokenID				token_id,
				TokenStatus			token_status)
{
	DomainMCSPDU		token_inhibit_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_inhibit_confirm_pdu.choice = TOKEN_INHIBIT_CONFIRM_CHOSEN;
	token_inhibit_confirm_pdu.u.token_inhibit_confirm.result =
			(PDUResult)result;
	token_inhibit_confirm_pdu.u.token_inhibit_confirm.initiator = uidInitiator;
	token_inhibit_confirm_pdu.u.token_inhibit_confirm.token_id = token_id;
	token_inhibit_confirm_pdu.u.token_inhibit_confirm.token_status =
			(PDUTokenStatus)token_status;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_inhibit_confirm_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenGiveRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenGiveRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenGiveRequest (
				PTokenGiveRecord	pTokenGiveRec)
{
	DomainMCSPDU		token_give_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_give_request_pdu.choice = TOKEN_GIVE_REQUEST_CHOSEN;
	token_give_request_pdu.u.token_give_request.initiator = pTokenGiveRec->uidInitiator;
	token_give_request_pdu.u.token_give_request.token_id = pTokenGiveRec->token_id;
	token_give_request_pdu.u.token_give_request.recipient = pTokenGiveRec->receiver_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_give_request_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	TokenGiveIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenGiveIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenGiveIndication (
				PTokenGiveRecord	pTokenGiveRec)
{
	DomainMCSPDU		token_give_indication_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_give_indication_pdu.choice = TOKEN_GIVE_INDICATION_CHOSEN;
	token_give_indication_pdu.u.token_give_indication.initiator = pTokenGiveRec->uidInitiator;
	token_give_indication_pdu.u.token_give_indication.token_id = pTokenGiveRec->token_id;
	token_give_indication_pdu.u.token_give_indication.recipient = pTokenGiveRec->receiver_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_give_indication_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenGiveResponse ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenGiveResponse" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenGiveResponse (
				Result				result,
				UserID				receiver_id,
				TokenID				token_id)
{
	DomainMCSPDU		token_give_response_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_give_response_pdu.choice = TOKEN_GIVE_RESPONSE_CHOSEN;
	token_give_response_pdu.u.token_give_response.result =
			(PDUResult)result;
	token_give_response_pdu.u.token_give_response.recipient = receiver_id;
	token_give_response_pdu.u.token_give_response.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_give_response_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	TokenGiveConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenGiveConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenGiveConfirm (
				Result				result,
				UserID				uidInitiator,
				TokenID				token_id,
				TokenStatus			token_status)
{
	DomainMCSPDU		token_give_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_give_confirm_pdu.choice = TOKEN_GIVE_CONFIRM_CHOSEN;
	token_give_confirm_pdu.u.token_give_confirm.result =
			(PDUResult)result;
	token_give_confirm_pdu.u.token_give_confirm.initiator = uidInitiator;
	token_give_confirm_pdu.u.token_give_confirm.token_id = token_id;
	token_give_confirm_pdu.u.token_give_confirm.token_status =
			(PDUTokenStatus)token_status;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_give_confirm_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	TokenPleaseRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenPleaseRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenPleaseRequest (
				UserID				uidInitiator,
				TokenID				token_id)
{
	DomainMCSPDU		token_please_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_please_request_pdu.choice = TOKEN_PLEASE_REQUEST_CHOSEN;
	token_please_request_pdu.u.token_please_request.initiator = uidInitiator;
	token_please_request_pdu.u.token_please_request.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_please_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenPleaseIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenPleaseIndication" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenPleaseIndication (
				UserID				uidInitiator,
				TokenID				token_id)
{
	DomainMCSPDU		token_please_indication_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_please_indication_pdu.choice = TOKEN_PLEASE_INDICATION_CHOSEN;
	token_please_indication_pdu.u.token_please_request.initiator = uidInitiator;
	token_please_indication_pdu.u.token_please_request.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_please_indication_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenReleaseRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenReleaseRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenReleaseRequest (
				UserID				uidInitiator,
				TokenID				token_id)
{
	DomainMCSPDU		token_release_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_release_request_pdu.choice = TOKEN_RELEASE_REQUEST_CHOSEN;
	token_release_request_pdu.u.token_release_request.initiator = uidInitiator;
	token_release_request_pdu.u.token_release_request.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_release_request_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenReleaseConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenReleaseConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenReleaseConfirm (
				Result				result,
				UserID				uidInitiator,
				TokenID				token_id,
				TokenStatus			token_status)
{
	DomainMCSPDU		token_release_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_release_confirm_pdu.choice = TOKEN_RELEASE_CONFIRM_CHOSEN;
	token_release_confirm_pdu.u.token_release_confirm.result =
			(PDUResult)result;
	token_release_confirm_pdu.u.token_release_confirm.initiator = uidInitiator;
	token_release_confirm_pdu.u.token_release_confirm.token_id = token_id;
	token_release_confirm_pdu.u.token_release_confirm.token_status =
			(PDUTokenStatus)token_status;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_release_confirm_pdu, DOMAIN_MCS_PDU,
			TOP_PRIORITY);
}

/*
 *	Void	TokenTestRequest ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenTestRequest" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenTestRequest (
				UserID				uidInitiator,
				TokenID				token_id)
{
	DomainMCSPDU		token_test_request_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_test_request_pdu.choice = TOKEN_TEST_REQUEST_CHOSEN;
	token_test_request_pdu.u.token_test_request.initiator = uidInitiator;
	token_test_request_pdu.u.token_test_request.token_id = token_id;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_test_request_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	TokenTestConfirm ()
 *
 *	Public
 *
 *	Functional Description:
 *		This routine is called by the domain in order to send a
 *		"TokenTestConfirm" PDU through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::TokenTestConfirm (
				UserID				uidInitiator,
				TokenID				token_id,
				TokenStatus			token_status)
{
	DomainMCSPDU		token_test_confirm_pdu;

	/*
	 *	Fill in the PDU structure to be encoded.
	 */
	token_test_confirm_pdu.choice = TOKEN_TEST_CONFIRM_CHOSEN;
	token_test_confirm_pdu.u.token_test_confirm.initiator = uidInitiator;
	token_test_confirm_pdu.u.token_test_confirm.token_id = token_id;
	token_test_confirm_pdu.u.token_test_confirm.token_status =
			(PDUTokenStatus)token_status;

	/*
	 *	Send the packet to the remote provider.
	 */
	SendPacket ((PVoid) &token_test_confirm_pdu, DOMAIN_MCS_PDU, TOP_PRIORITY);
}

/*
 *	Void	MergeDomainIndication ()
 *
 *	Public
 *
 *	Functional Description:
 *		This function is called when the attached domain enters or leaves the
 *		merge state.
 */
Void	Connection::MergeDomainIndication (
				MergeStatus			merge_status)
{
	/*
	 *	If this indication shows that a domain merger is in progress, set the
	 *	boolean flag that prevents the sending of MCS commands to the domain.
	 *	Otherwise, reset it.
	 */
	if (merge_status == MERGE_DOMAIN_IN_PROGRESS)
	{
		TRACE_OUT (("Connection::MergeDomainIndication: entering merge state"));
		Merge_In_Progress = TRUE;
	}
	else
	{
		TRACE_OUT (("Connection::MergeDomainIndication: leaving merge state"));
		Merge_In_Progress = FALSE;
	}
}

/*
 *	Void	SendPacket ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine is called in order to create a packet which will hold
 *		the PDU to be sent to the remote provider.  The packet will be queued
 *		up for transmission through the transport interface.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::SendPacket (
				PVoid				pdu_structure,
				int					pdu_type,
				Priority			priority)
{
	unsigned int	encoding_rules;
	PPacket			packet;
	PacketError		packet_error;
	BOOL    		bFlush;

	/*
	 *	Set the appropriate encoding rules for this PDU according to what type
	 *	it is.
	 */
	if (pdu_type == CONNECT_MCS_PDU) {
		encoding_rules = BASIC_ENCODING_RULES;
		bFlush = FALSE;
//		TRACE_OUT(("Connect SendPacket: PDU type: %d", (UINT) ((ConnectMCSPDU *) pdu_structure)->choice));
	}
	else {
		encoding_rules = Encoding_Rules;
		bFlush = TRUE;
//		TRACE_OUT(("Domain SendPacket: PDU type: %d", (UINT) ((DomainMCSPDU *) pdu_structure)->choice));
	}

	/*
	 *	Create a packet which will be used to hold the data to be sent
	 *	through the transport interface.	 Check to make sure the packet is
	 *	successfully created.  Issue a callback to the controller requesting
	 *	deletion of this connection if the packet is not successfully created.
	 */
	 DBG_SAVE_FILE_LINE
	 packet = new Packet (
	 		(PPacketCoder) g_MCSCoder,
			encoding_rules,
			pdu_structure,
			(int) pdu_type,
			Upward_Connection,
			&packet_error);

	if (packet != NULL)
	{
		if (packet_error == PACKET_NO_ERROR)
		{
			/*
			 *	Lock the encoded PDU data and queue the packet up for
			 *	transmission through the transport interface.
			 */
			QueueForTransmission ((PSimplePacket) packet, priority, bFlush);
		}
		else
		{
			/*
			 *	The packet creation has failed due to an internal error so
			 *	issue an owner callback to ask for deletion.
			 */
			DestroyConnection (REASON_PROVIDER_INITIATED);
		}

		/*
		 *	The packet is freed here so that it will be deleted when it's lock
		 *	count reaches zero.
		 */
		packet->Unlock ();
	}
	else
	{
		/*
		 *	The packet creation has failed so issue an owner callback
		 *	to ask for deletion.
		 */
		DestroyConnection (REASON_PROVIDER_INITIATED);
	}
}

/*
 *	Void	QueueForTransmission()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine encodes a PDU and places data units into the transmission queue so
 *		they can be transmitted through the transport interface when possible.
 *		An attempt is made to flush the queue and the transmitter is polled
 *		in order to go ahead and send the data immediately, if possible, instead
 *		of waiting for a timer event to occur.
 *
 *	Caveats:
 *		None.
 */
Void	Connection::QueueForTransmission (
				PSimplePacket		packet,
				Priority			priority,
				BOOL    			bFlush)
{

		int			 p;
	
	ASSERT (g_Transport != NULL);
	packet->Lock();

	/*
	 *	Attempt to set the packet directly to the transport without queueing it.
	 *	If this is done, it can eliminate queueing time and a thread switch.
	 *	For this to be possible, all higher priorities must have no pending
	 *	packets and the bFlush parameter should be TRUE.
	 */
	if (bFlush) {
		for (p = (int) TOP_PRIORITY; p <= (int) priority; p++) {
			if (m_OutPktQueue[p].GetCount() > 0)
				break;
		}

		if (p > priority) {
			/*
			 * There are no packets queued up for higher priorities. We can attempt
			 * to send the packet directly, by-passing the queue.
			 */
			if (FlushAMessage (packet, priority)) {
				return;
			}
		}
	}
				
	/*
	 *	Place the data unit in the proper queue. Increment the counter for that
	 *	queue and increment the transmission counter.
	 */
	m_OutPktQueue[priority].Append(packet);

	/*
	 *	If this is the first packet queued up for the specified priority,
	 *	then we must send a DataRequestReady to the transport interface
	 *	object.  Note that if other packets are already queued up, then it
	 *	is not necessary to inform the transport interface object, since it
	 *	already knows it has at least one).
	 */
	if (m_OutPktQueue[priority].GetCount() == 1)
		g_Transport->DataRequestReady ();
}

/*
 *	BOOL    FlushAMessage()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine will only flush one MCS PDU to the transport layer.
 *
 *	Parameters:
 *		packet: the packet to send.
 *		priority: the packet's priority
 *
 *	Return value:
 *		TRUE, if the message was successfully sent. FALSE, otherwise.
 *
 */
BOOL    Connection::FlushAMessage (PSimplePacket packet, Priority priority)
{	
	if (Domain_Traffic_Allowed == FALSE && packet->GetPDUType () == DOMAIN_MCS_PDU) {
		return FALSE;
	}

	if (packet->IsDataPacket())
		((PDataPacket) packet)->SetDirection (Upward_Connection);
			
	/*
	 *	Send the PDU to the transport interface.
	 */
	 if (DataRequest (Transport_Connection[priority], packet) != TRANSPORT_WRITE_QUEUE_FULL) {
		packet->Unlock();
		return TRUE;
	}

	return FALSE;
}

/*
 *	Void	FlushMessageQueue()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine flushes the transmit queue by copying the data unit
 *		into the output buffer and calling into the transport interface to
 *		give it a chance to accept the data.
 *
 *	Return value:
 *		TRUE, if there remain un-processed msgs in the connection message queue
 *		FALSE, if all the msgs in the connection msg queue were processed.
 *
 *	Caveats:
 *		None.
 */
BOOL    Connection::FlushMessageQueue()
{
	int				priority;
	BOOL    		return_value = FALSE;

	ASSERT (g_Transport != NULL);
		
	/*
	 *	Loop through all four priority levels of transmission queues.
	 */
	for (priority = 0; priority < MAXIMUM_PRIORITIES; priority++) {
		if (m_OutPktQueue[priority].GetCount() > 0) {
			return_value |= FlushPriority ((Priority) priority);
		}
	}

	return (return_value);
}

/*
 *	BOOL    FlushPriority ()
 *
 *	Private
 *
 *	Functional Description:
 *
 *	Return value:
 *		TRUE, if there remain un-processed msgs in the connection message queue
 *		FALSE, if all the msgs in the connection msg queue were processed.
 *
 *	Caveats:
 *		None.
 */
BOOL    Connection::FlushPriority (
				Priority		priority)
{
	PSimplePacket	packet;
	BOOL    		return_value = FALSE;

	/*
	 *	Check to see if the transport connection for this priority is
	 *	ready.  If not, skip it for now.
	 */
	if (Transport_Connection_State[priority] == TRANSPORT_CONNECTION_READY)
	{
		/*
		 *	If there is no packet in the queue, we may be here to send the
		 *	remainder of a packet that has been accepted by transport earlier.
		 *	We need to flush this remainder of the packet.
		 */
		if (m_OutPktQueue[priority].IsEmpty()) {
			if (DataRequest (Transport_Connection[priority], NULL) == TRANSPORT_WRITE_QUEUE_FULL) {
				return_value = TRUE;
			}
		}
		else {
			/*
			 *	While data exists in this queue and the transport interface is
			 *	able to accept it, retrieve the next packet from the queue and
			 *	send the data to the transport interface.
			 */
			while (NULL != (packet = m_OutPktQueue[priority].Get()))
			{
				if (! FlushAMessage (packet, priority))
				{
					/*
					 *	If the transport layer has rejected the PDU, then it is
					 *	necessary to leave it in the queue (at the front).
					 *	Then break out of the loop to prevent additional
					 *	attempts to transmit data at this priority.
					 */
					return_value = TRUE;
					if (packet != NULL) {
						m_OutPktQueue[priority].Prepend(packet);
					}
					break;
				}
			}
		}
	}
	else
		return_value = TRUE;

	return (return_value);
}

/*
 *	ULong	OwnerCallback()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine allows the transport interface to call into the connection
 *		in order to notify the connection of data reception.  This routine
 *		decodes the incoming data, notifies the controller if necessary and/or
 *		makes the necessary calls into the domain.
 *
 *	Caveats:
 *		None.
 */

TransportError Connection::HandleDataIndication
(
    PTransportData          pTransport_data,
    TransportConnection     transport_connection
)
{
    int             priority;
    TransportError  rc = TRANSPORT_NO_ERROR;

    /*
     *	Data is being received through the transport interface.  Determine
     *	what priority this data is arriving at.  This will be used to see
     *	what type of PDU this is supposed to be (CONNECT or DOMAIN).
     */
    for (priority = 0; priority < MAXIMUM_PRIORITIES; priority++)
    {
        if (IS_SAME_TRANSPORT_CONNECTION(Transport_Connection[priority], transport_connection))
        {
            break;
        }
    }

    /*
     *	Make sure that this transport connection was somewhere in the the
     *	transport connection list before processing the PDU.  If it was not,
     *	then report an error and ignore the PDU.
     */
    if (priority < MAXIMUM_PRIORITIES)
    {
        int						pdu_type;
        unsigned int			encoding_rules;
        PSimplePacket			packet;
        PacketError				packet_error;
        PVoid					pdu_structure;
        /*
         *	Determine what type of PDU this should be.
         */
        pdu_type = Transport_Connection_PDU_Type[priority];

        /*
         *	Set the appropriate encoding rules for this PDU according to
         *	what type it is.
         */
        encoding_rules = (pdu_type == CONNECT_MCS_PDU) ? BASIC_ENCODING_RULES :
                                                         Encoding_Rules;

        /*
         *	Get the pointer to the data indication structure from the the
         *	parameter list.  Then construct a packet object to represent
         *	this inbound data.
         */

        /*
         *	Crete a Packet or a DataPacket, depending on whether this
         *	is an MCS data packet.
         */
        if (g_MCSCoder->IsMCSDataPacket (
        					pTransport_data->user_data + PROTOCOL_OVERHEAD_X224,
        					encoding_rules))
        {
        	ASSERT (encoding_rules == PACKED_ENCODING_RULES);
        	
        	DBG_SAVE_FILE_LINE
        	packet = (PSimplePacket) new DataPacket (pTransport_data,
        										! Upward_Connection);
        	packet_error = PACKET_NO_ERROR;
        }
        else
        {
        	DBG_SAVE_FILE_LINE
        	packet = (PSimplePacket) new Packet (
        			(PPacketCoder) g_MCSCoder,
        			encoding_rules,
        			pTransport_data->user_data + PROTOCOL_OVERHEAD_X224,
        			pTransport_data->user_data_length - PROTOCOL_OVERHEAD_X224,
        			pdu_type, ! Upward_Connection,
        			&packet_error);
        }
        if (packet != NULL)
        {
            if (packet_error == PACKET_NO_ERROR)
            {
                /*
                 *	Retrieve a pointer to the decoded data
                 */
                pdu_structure = packet->GetDecodedData ();

                /*
                 *	Process the PDU according to what type it is.
                 */
                if (pdu_type == CONNECT_MCS_PDU)
                {
                    switch (((PConnectMCSPDU) pdu_structure)->choice)
                    {
                    case CONNECT_RESPONSE_CHOSEN:
                    	rc = ProcessConnectResponse (
                    			&((PConnectMCSPDU) pdu_structure)->
                    			u.connect_response);

                    	/*
                    	 *	Now that we have received and processed a
                    	 *	connect PDU over this transport connection,
                    	 *	we must indicate that the next PDU received
                    	 *	must be a domain PDU.
                    	 */
                    	Transport_Connection_PDU_Type[priority] =
                    			DOMAIN_MCS_PDU;
                    	break;

                    case CONNECT_RESULT_CHOSEN:
                    	ProcessConnectResult (
                    			&((PConnectMCSPDU) pdu_structure)->
                    			u.connect_result);

                    	/*
                    	 *	Now that we have received and processed a
                    	 *	connect PDU over this transport connection,
                    	 *	we must indicate that the next PDU received
                    	 *	must be a domain PDU.
                    	 */
                    	Transport_Connection_PDU_Type[priority] =
                    			DOMAIN_MCS_PDU;
                    	break;

                    default:
                    	/*
                    	 *	We have received a PDU that should not have
                    	 *	been received.  Ignore it.
                    	 */
                    	ERROR_OUT (("Connection::HandleDataIndication: Unknown ConnectMCSPDU Rxd"));
                    	break;
                    }
                }
                else
                {
                    /*
                    *	Verify that current conditions are appropriate for a request to be
                    *	accepted from a transport connection.
                    */
                    rc = ValidateConnectionRequest ();
                    if (rc == TRANSPORT_NO_ERROR)
                    {
                        switch (((PDomainMCSPDU) pdu_structure)->choice)
                        {
                        case SEND_DATA_REQUEST_CHOSEN:
                        	ProcessSendDataRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		send_data_request, (PDataPacket) packet);
                        	break;

                        case SEND_DATA_INDICATION_CHOSEN:
                        	ProcessSendDataIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		send_data_indication, (PDataPacket) packet);
                        	break;

                        case UNIFORM_SEND_DATA_REQUEST_CHOSEN:
                        	ProcessUniformSendDataRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		uniform_send_data_request, (PDataPacket) packet);
                        	break;

                        case UNIFORM_SEND_DATA_INDICATION_CHOSEN:
                        	ProcessUniformSendDataIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		uniform_send_data_indication, (PDataPacket) packet);
                        	break;

                        case PLUMB_DOMAIN_INDICATION_CHOSEN:
                        	ProcessPlumbDomainIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		plumb_domain_indication);
                        	break;

                        case ERECT_DOMAIN_REQUEST_CHOSEN:
                        	ProcessErectDomainRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		erect_domain_request);
                        	break;

                        case MERGE_CHANNELS_REQUEST_CHOSEN:
                        	rc = ProcessMergeChannelsRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		merge_channels_request);
                        	break;

                        case MERGE_CHANNELS_CONFIRM_CHOSEN:
                        	rc = ProcessMergeChannelsConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		merge_channels_confirm);
                        	break;

                        case PURGE_CHANNEL_INDICATION_CHOSEN:
                        	ProcessPurgeChannelIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		purge_channel_indication);
                        	break;

                        case MERGE_TOKENS_REQUEST_CHOSEN:
                        	rc = ProcessMergeTokensRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		merge_tokens_request);
                        	break;

                        case MERGE_TOKENS_CONFIRM_CHOSEN:
                        	rc = ProcessMergeTokensConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		merge_tokens_confirm);
                        	break;

                        case PURGE_TOKEN_INDICATION_CHOSEN:
                        	ProcessPurgeTokenIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		purge_token_indication);
                        	break;

                        case DISCONNECT_PROVIDER_ULTIMATUM_CHOSEN:
                        	ProcessDisconnectProviderUltimatum (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		disconnect_provider_ultimatum);
                        	break;

                        case REJECT_ULTIMATUM_CHOSEN:
                        	ProcessRejectUltimatum (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		reject_user_ultimatum);
                        	break;

                        case ATTACH_USER_REQUEST_CHOSEN:
                        	ProcessAttachUserRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		attach_user_request);
                        	break;

                        case ATTACH_USER_CONFIRM_CHOSEN:
                        	ProcessAttachUserConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		attach_user_confirm);
                        	break;

                        case DETACH_USER_REQUEST_CHOSEN:
                        	ProcessDetachUserRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		detach_user_request);
                        	break;

                        case DETACH_USER_INDICATION_CHOSEN:
                        	ProcessDetachUserIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		detach_user_indication);
                        	break;

                        case CHANNEL_JOIN_REQUEST_CHOSEN:
                        	ProcessChannelJoinRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_join_request);
                        	break;

                        case CHANNEL_JOIN_CONFIRM_CHOSEN:
                        	ProcessChannelJoinConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_join_confirm);
                        	break;

                        case CHANNEL_LEAVE_REQUEST_CHOSEN:
                        	ProcessChannelLeaveRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_leave_request);
                        	break;

                        case CHANNEL_CONVENE_REQUEST_CHOSEN:
                        	ProcessChannelConveneRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_convene_request);
                        	break;

                        case CHANNEL_CONVENE_CONFIRM_CHOSEN:
                        	ProcessChannelConveneConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_convene_confirm);
                        	break;

                        case CHANNEL_DISBAND_REQUEST_CHOSEN:
                        	ProcessChannelDisbandRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_disband_request);
                        	break;

                        case CHANNEL_DISBAND_INDICATION_CHOSEN:
                        	ProcessChannelDisbandIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_disband_indication);
                        	break;

                        case CHANNEL_ADMIT_REQUEST_CHOSEN:
                        	ProcessChannelAdmitRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_admit_request);
                        	break;

                        case CHANNEL_ADMIT_INDICATION_CHOSEN:
                        	ProcessChannelAdmitIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_admit_indication);
                        	break;

                        case CHANNEL_EXPEL_REQUEST_CHOSEN:
                        	ProcessChannelExpelRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_expel_request);
                        	break;

                        case CHANNEL_EXPEL_INDICATION_CHOSEN:
                        	ProcessChannelExpelIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		channel_expel_indication);
                        	break;

                        case TOKEN_GRAB_REQUEST_CHOSEN:
                        	ProcessTokenGrabRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_grab_request);
                        	break;

                        case TOKEN_GRAB_CONFIRM_CHOSEN:
                        	ProcessTokenGrabConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_grab_confirm);
                        	break;

                        case TOKEN_INHIBIT_REQUEST_CHOSEN:
                        	ProcessTokenInhibitRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_inhibit_request);
                        	break;

                        case TOKEN_INHIBIT_CONFIRM_CHOSEN:
                        	ProcessTokenInhibitConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_inhibit_confirm);
                        	break;

                        case TOKEN_GIVE_REQUEST_CHOSEN:
                        	ProcessTokenGiveRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_give_request);
                        	break;

                        case TOKEN_GIVE_INDICATION_CHOSEN:
                        	ProcessTokenGiveIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_give_indication);
                        	break;

                        case TOKEN_GIVE_RESPONSE_CHOSEN:
                        	ProcessTokenGiveResponse (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_give_response);
                        	break;

                        case TOKEN_GIVE_CONFIRM_CHOSEN:
                        	ProcessTokenGiveConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_give_confirm);
                        	break;

                        case TOKEN_PLEASE_REQUEST_CHOSEN:
                        	ProcessTokenPleaseRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_please_request);
                        	break;

                        case TOKEN_PLEASE_INDICATION_CHOSEN:
                        	ProcessTokenPleaseIndication (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_please_indication);
                        	break;

                        case TOKEN_RELEASE_REQUEST_CHOSEN:
                        	ProcessTokenReleaseRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_release_request);
                        	break;

                        case TOKEN_RELEASE_CONFIRM_CHOSEN:
                        	ProcessTokenReleaseConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_release_confirm);
                        	break;

                        case TOKEN_TEST_REQUEST_CHOSEN:
                        	ProcessTokenTestRequest (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_test_request);
                        	break;

                        case TOKEN_TEST_CONFIRM_CHOSEN:
                        	ProcessTokenTestConfirm (
                        		&((PDomainMCSPDU) pdu_structure)->u.
                        		token_test_confirm);
                        	break;

                        default:
                        	ERROR_OUT (("Connection::HandleDataIndication: Unknown DomainMCSPDU Rxd"));
                        	break;
                        }
                    }
                    else
                    {
                        ASSERT (TRANSPORT_READ_QUEUE_FULL == rc);
                        if (packet->IsDataPacket())
                        {
                            /*
                             * We are returning TRANSPORT_READ_QUEUE_FULL to the transport.
                             * The transport will attempt to deliver the data again later.
                             * However, we have to delete the DataPacket we created here, which
                             * will attempt to free the buffer that will be delivered again
                             * later.  So, let's lock it now.
                             */
                            LockMemory (pTransport_data->memory);
                        }
                    }
                }

                /* If this was a non-data PDU, we need to free up the transport
                 *	buffer with the original data.
                 */
                if ((! packet->IsDataPacket()) && (rc == TRANSPORT_NO_ERROR))
                    FreeMemory (pTransport_data->memory);

                /*
                 *	Free the packet.  This will result in the destruction of the
                 *	packet unless it is a "Send Data" packet which has been
                 *	locked by someone else.
                 */
                packet->Unlock ();

            }
            else
            {
                /*
                 *	Although the construction of the packet object itself
                 *	was successful, an error was generated in its
                 *	constructor.  We must therefore reject the packet.
                 */
                WARNING_OUT (("Connection::HandleDataIndication: packet constructor failure"));
                delete packet;
                rc = TRANSPORT_READ_QUEUE_FULL;
            }
        }
        else
        {
            /*
             *	We were not able to construct a packet object to represent
             *	the inbound data.  It is therefore necessary to reject the
             *	data from the transport layer, so that it can be retried
             *	later.
             */
            WARNING_OUT (("Connection::HandleDataIndication: packet allocation failure"));
            rc = TRANSPORT_READ_QUEUE_FULL;
        }
    }
    else
    {
        /*
         *	This transport connection is not listed as one of the ones being
         *	used by this MCS connection.  It is therefore necessary to
         *	ignore the PDU.
         */
        WARNING_OUT (("Connection::HandleDataIndication: unknown transport connection"));
    }
    return rc;
}

void Connection::HandleBufferEmptyIndication
(
    TransportConnection     transport_connection
)
{
    /*
    *	Determine what priority this indication is associated with.
    */
    for (int priority = 0; priority < MAXIMUM_PRIORITIES; priority++)
    {
        if (IS_SAME_TRANSPORT_CONNECTION(Transport_Connection[priority], transport_connection))
        /*
         *	Try to flush existing data downward.
         */
        FlushPriority ((Priority) priority);
    }
}

void Connection::HandleConnectConfirm
(
    TransportConnection     transport_connection
)
{
    /*
    *	A confirm has been received as the result of an outbound connect
    *	request.  This tells us that the request was successful.
    */
    TRACE_OUT (("Connection::HandleConnectConfirm: received CONNECT_CONFIRM"));

    for (int priority = 0; priority < MAXIMUM_PRIORITIES; priority++)
    {
        if (IS_SAME_TRANSPORT_CONNECTION(Transport_Connection[priority], transport_connection) &&
            (Transport_Connection_State[priority] == TRANSPORT_CONNECTION_PENDING))
        {
            Transport_Connection_State[priority] = TRANSPORT_CONNECTION_READY;
        }
    }
}

void Connection::HandleDisconnectIndication
(
    TransportConnection     transport_connection,
    ULONG                  *pnNotify
)
{
    Reason reason;
    /*
     *	A disconnection indication has been received through the transport
     *	interface.  Notify the controller and the domain and set the flag
     *	indicating a connection deletion is pending.
     */
    TRACE_OUT (("Connection::HandleDisconnectIndication: received DISCONNECT_INDICATION"));

    /*
     *	For each priority level that is using that disconnected
     *	transport connection, mark it as unassigned.  This serves two
     *	purposes.  First, it prevents any attempt to send data on the
     *	transport connection that is no longer valid.  Second, it
     *	prevents the destructor of this object from sending a
     *	disconnect request.
     */
    for (int priority = 0; priority < MAXIMUM_PRIORITIES; priority++)
    {
        if (IS_SAME_TRANSPORT_CONNECTION(Transport_Connection[priority], transport_connection))
        {
            Transport_Connection_State[priority] = TRANSPORT_CONNECTION_UNASSIGNED;
        }
    }

    /*
     *	Losing ANY of its transport connections is fatal to an MCS
     *	connection.  Therefore, this connection object must delete
     *	itself.
     */
    ASSERT(pnNotify);
    switch (*pnNotify)
    {
    case TPRT_NOTIFY_REMOTE_NO_SECURITY :
    	reason = REASON_REMOTE_NO_SECURITY;
    	break;
    case TPRT_NOTIFY_REMOTE_DOWNLEVEL_SECURITY :
    	reason = REASON_REMOTE_DOWNLEVEL_SECURITY;
    	break;

	case TPRT_NOTIFY_REMOTE_REQUIRE_SECURITY :
		reason = REASON_REMOTE_REQUIRE_SECURITY;
		break;

	case TPRT_NOTIFY_AUTHENTICATION_FAILED:
		reason = REASON_AUTHENTICATION_FAILED;
		break;
	
    default :
    	reason = REASON_DOMAIN_DISCONNECTED;
    	break;
    }
    DestroyConnection (reason);
}


void CChannelIDList::BuildExternalList(PSetOfChannelIDs *ppChannelIDs)
{
    PSetOfChannelIDs p = *ppChannelIDs;
    ChannelID chid;
    if (p != NULL)
    {
        /*
         *	Iterate through the set of channel ids, filling in the PDU
         *	structure.
         */
        for (Reset(); NULL != (chid = Iterate()); p++)
        {
            p->value = chid;
            p->next = p + 1;
        }

        /*
         *	Decrement the pointer in order to set the last "next"
         *	pointer to NULL.
         */
        (p - 1)->next = NULL;
        *ppChannelIDs = p;
    }
}


void CTokenIDList::BuildExternalList(PSetOfTokenIDs *ppTokenIDs)
{
    PSetOfTokenIDs p = *ppTokenIDs;
    TokenID tid;
    if (p != NULL)
    {
        /*
         *	Iterate through the set of token ids, filling in the PDU
         *	structure.
         */
        for (Reset(); NULL != (tid = Iterate()); p++)
        {
            p->value = tid;
            p->next = p + 1;
        }

        /*
         *	Decrement the pointer in order to set the last "next"
         *	pointer to NULL.
         */
        (p - 1)->next = NULL;
        *ppTokenIDs = p;
    }
}


void CUidList::BuildExternalList(PSetOfUserIDs *ppUserIDs)
{
    PSetOfUserIDs p = *ppUserIDs;
    UserID uid;
    if (p != NULL)
    {
        /*
         *	Iterate through the set of user ids, filling in the PDU
         *	structure.
         */
        for (Reset(); NULL != (uid = Iterate()); p++)
        {
            p->value = uid;
            p->next = p + 1;
        }

        /*
         *	Decrement the pointer in order to set the last "next"
         *	pointer to NULL.
         */
        (p - 1)->next = NULL;
        *ppUserIDs = p;
    }
}