windows-server-2003/enduser/netmeeting/t120/mst120/control.cpp

#include "precomp.h"
#include "cnpcoder.h"
DEBUG_FILEZONE(ZONE_T120_MCSNC);
/*
 *	control.cpp
 *
 *	Copyright (c) 1993 - 1996 by DataBeam Corporation, Lexington, KY
 *
 *	Abstract:
 *		This is the implementation file for the MCS controller.  Its primary
 *		purpose is to create and destroy objects as needed at run-time.  The
 *		interface file contains a detailed description of what this class
 *		does.
 *
 *		There can be only one instance of this object within an MCS provider.
 *		Once initialization is complete, this object performs all activity
 *		as part of an owner callback from one of its "children".
 *
 *		The owner callback member function determines which callback is
 *		occurring, unpacks the parameters, and calls a private member function
 *		that is associated with that callback.  So when reading through the
 *		code, it is possible to view those private member functions as though
 *		they were direct calls from the child objects.  It is worth noting
 *		that all of the owner callback private member functions follow the
 *		same naming convention.  The function name is the name of the
 *		originating object followed by the name of the operation.  For
 *		example,  if an application interface object sends a create domain
 *		request to the controller through the owner callback, the name of
 *		the associated member function is ApplicationCreateDomain.  When a
 *		connection object wishes to delete itself, this is called
 *		ConnectionDeleteConnection.
 *
 *		The Windows version of the constructor can optionally allocate a
 *		Windows timer to provider MCS with a heartbeat.  The timer procedure
 *		uses a static variable to "jump into" the context of the controller
 *		object.  For this reason, there can only be one instance of this class.
 *
 *		This class is also responsible for sending four different messages
 *		to the node controller: connect provider indication; connect provider
 *		confirm; disconnect provider indication; and transport status
 *		indication.  A control queue is maintained to buffer these indications
 *		and confirms until the next time slice.
 *
 *	Private Instance Variables:
 *		Connection_Handle_Counter
 *			A rolling counter used by the controller to generate connection
 *			handles.  It is 16-bit, and will not repeat a handle until all 64K
 *			have been used (0 is NOT a valid handle).
 *		ASN_Coder
 *			When using the DataBeam's implementation of ASN.1, this is the
 *			ASN coder.  When the MCS coder is created, this object is passed
 *			to it, but this instance variable allows us to later delete this
 *			object.
 *		m_DomainList2
 *			A list of existing Domains, indexed by DomainSelector.  These are
 *			created when the controller receives a CreateDomain.
 *		m_ConnectionList2
 *			A list of existing Connections, indexed by ConnectionHandle.  These
 *			are created in one of two ways.  First, in response to a locally
 *			generated ConnectProviderRequest (with a valid local domain and
 *			transport address).  Second, in response to a locally generated
 *			ConnectProviderResponse (which is responding to an incoming
 *			connection).
 *		m_ConnPollList
 *			This is a list of active connection objects which is used for
 *			polling in the heartbeat call.  The order of the entries is modified
 *			every heartbeat in order to provide fair access to resources.
 *		m_ConnPendingList2
 *			This is a list of incoming connections for which a connect provider
 *			response has not yet been received.  This list holds pertinent
 *			information about the pending connection that will not be passed
 *			back in the ConnectProviderResponse..
 *		m_ConnectionDeletionList2
 *			A list of connection objects awaiting deletion,
 *		Connection_Deletion_Pending
 *			A flag that indicates whether or not there is anything in the
 *			connection deletion list.
 *	Private Member Functions:
 *		LoadTransportStacks
 *			This function is called by the constructor to load all available
 *			transport stacks for use by MCS.  It reads the INI file to
 *			determine which DLLs are to be used, and then instantiate a
 *			transport interface object for each.  This code is NOT portable.
 *		ApplicationCreateDomain
 *			This is an owner callback function that results from a call to
 *			CreateDomain.  This callback comes from the application interface
 *			object that represents the originator of the request.  The named
 *			domain will be created (if it doesn't already exist).
 *		ApplicationDeleteDomain
 *			This is an owner callback function that results from a call to
 *			DeleteDomain.  This callback comes from the application interface
 *			object that represents the originator of the request.  The named
 *			domain will be deleted (if it exists).
 *		ApplicationConnectProviderRequest
 *			This is an owner callback function that occurs when the node
 *			controller calls ConnectProviderRequest.  After parameters are
 *			validated, a new connection object will be created.
 *		ApplicationConnectProviderResponse
 *			This is an owner callback function that occurs when the node
 *			controller calls ConnectProviderResponse.  The controller responds
 *			by sending a message to the proper domain object, letting it know
 *			whether an inbound connection was accepted or rejected.
 *		ApplicationDisconnectProviderRequest
 *			This is an owner callback function that occurs when the node
 *			controller calls DisconnectProviderRequest.  If the connection
 *			handle is valid, the associated connection object will be deleted.
 *		ApplicationAttachUserRequest
 *			This is an owner callback function that occurs when any application
 *			sends an AttachUserRequest via one of the active application
 *			interface objects.  The controller will create a new user object
 *			after parameter validation.
 *		ConnectionDeleteConnection
 *			This is an owner callback function that occurs when a connection
 *			object determines the need to delete itself.  This can occur for
 *			two reasons.  First, in response to a disconnect provider ultimatum
 *			from either the local or the remote domain.  Second, in response
 *			to a loss of connection from the transport layer.
 *		ConnectionConnectProviderConfirm
 *			This is an owner callback function that occurs when a connection
 *			object receives a connect response PDU from a remote provider for an
 *			outstanding connect initial.  The controller responds by sending a
 *			connect provider confirm to the node controller.
 *		TransportDataIndication
 *			This is an owner callback function that occurs when data is
 *			received on a transport connection for which no other object has
 *			registered.
 *		TransportStatusIndication
 *			This is an owner callback function that occurs when a status
 *			indication message comes from the transport layer.  This information
 *			is forwarded to the node controller in the form of a transport
 *			status indication message.
 *		ProcessConnectInitial
 *			Processes incoming connect initial PDUs.  Sends connect provider
 *			indication to the node controller.
 *		ProcessConnectAdditional
 *			Processes incoming connect additional PDUs.  Binds them to the
 *			appropriate connection, if possible.
 *		ConnectResponse
 *			Issues a failed connect response when something goes wrong.
 *		ConnectResult
 *			Issues a failed connect result when something goes wrong.
 *		AllocateConnectionHandle
 *			This private member function is used by the controller to allocate
 *			new connection handles when creating a new connection object.
 *		FlushMessageQueue
 *			This member function flushes the control message queue by sending
 *			all contained messages to the node controller.
 *
 *	Caveats:
 *		There can only one instance of this object at a time.
 *
 *	Author:
 *		James P. Galvin, Jr.
 */

/*
 *	External Interfaces
 */

#include <nmqos.h>
#include <t120qos.h>
#include "csap.h"

/*
 *	Macros
 */
enum
{
    TRANSPORT_TRANSMIT_EVENT,
    CONNECTION_DELETION_PENDING_EVENT,
    GCC_FLUSH_OUTGOING_PDU_EVENT,

    NUMBER_OF_EVENTS
};

/*
 *	Macros
 *
 *	These macros define the maximum length of various strings within the
 *	controller.  They are used when reading data from the INI file, which is
 *	very Windows specific.  These values are somewhat arbitrary and may be
 *	changed in future releases, if necessary.
 */
#define	MAXIMUM_CONFIGURATION_ITEM_LENGTH		20
#define	MAXIMUM_TRANSPORT_IDENTIFIER_LENGTH		40

/* The MSMCSTCP window class name. This name must be unique system-wide. */
#define MSMCSTCP_WINDOW_CLASS_NAME	"NM TCP Window"

/* 	Timer duration. We can get a timer event every X milliseconds.  During
 *	this time, we can do any maintenance that is necessary. */
#define	MSMCSTCP_TIMER_DURATION		30000

/*
 * This is the number of extra memory blocks that the local memory
 * manager can allocate.
 * This number should be set to 3 * prime number and close to the
 * maximum number of extra memory blocks that can be allocated.
 */
#define DEFAULT_MAX_EXTERNAL_MEMORY				237

/*
 *	This is a prototype for the controller thread entry point.
 */
ULong	APIENTRY	ControllerThread (PVoid);

// The DLL's HINSTANCE.
extern HINSTANCE		g_hDllInst;

// The TCP socket window handle
HWND					TCP_Window_Handle;

// The global MCS Critical Section
CRITICAL_SECTION 		g_MCS_Critical_Section;

/*
 *	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;

extern CCNPCoder        *g_CNPCoder;

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

BOOL GetSecurityInfo(ConnectionHandle connection_handle, PBYTE pInfo, PDWORD pcbInfo);
/*
 *	g_pMCSController
 *		This is a pointer to the one-and-only controller created within the
 *		MCS system.  This object is created during MCSInitialize by the process
 *		that is taking on the responsibilities of the node controller.
 */
PController				g_pMCSController = NULL;

// The MCS main thread handle
HANDLE 					g_hMCSThread = NULL;

/*
 *	These macros define the number of buckets to be used in various hash
 *	dictionaries that are maintained by the controller.  Having more buckets
 *	allows the dictionaries to handle more entries efficiently, but costs
 *	more resources.
 */
#define CONNECTION_LIST_NUMBER_OF_BUCKETS       16

/*
 *	Controller ()
 *
 *	Public
 *
 *	Functional Description:
 *		This is the constructor for the Controller.  It creates the application
 *		interface and transport interface objects that will be used by MCS.
 *		It also creates the memory manager object that will used throughout
 *		the system by anyone requiring memory management services.  And its
 *		last duty is to allocate a Windows timer for use in getting a time
 *		slice within which MCS does its work.
 */
Controller::Controller
(
    PMCSError       mcs_error
) 
:
    CRefCount(MAKE_STAMP_ID('M','C','t','r')),
    m_DomainList2(),
    m_ConnectionList2(CONNECTION_LIST_NUMBER_OF_BUCKETS),
    m_ConnPendingList2(),
    m_ConnectionDeletionList2(CONNECTION_LIST_NUMBER_OF_BUCKETS)
{
	ULong								thread_id;
	TransportInterfaceError				transport_interface_error;

	/*
	 *	Initialize the return value to indicate that no error has yet occured.
	 */
	*mcs_error = MCS_NO_ERROR;

	// Perform memory pool allocation for DataPacket objects.
	DataPacket::AllocateMemoryPool (ALLOCATE_DATA_PACKET_OBJECTS);

	/*
	 *	Give all pointers and handles initial values so that the destructor
	 *	will not try to free unallocated resources when the constructor fails
	 *	part-way.
	 */
	TCP_Window_Handle = NULL;
	Transport_Transmit_Event = NULL;
	Connection_Deletion_Pending_Event = NULL;
	m_fControllerThreadActive = FALSE;
#ifndef NO_TCP_TIMER
	Timer_ID = 0;
#endif	/* NO_TCP_TIMER */

	/*
	 *	Initialize the handle counters to 0.  These rolling instance variables
	 *	are used to generate uniwue handles as each user and connection object
	 *	is created.
	 */
	Connection_Handle_Counter = 0;
	Connection_Deletion_Pending = FALSE;

	// Initialize MCS's critical section.
	InitializeCriticalSection (&g_MCS_Critical_Section);

	/*
	 *	Create an ASN.1 coder which will encode all ASN.1 PDUs.  Check
	 *	to make sure the coder was successfully created.
	 */
	DBG_SAVE_FILE_LINE
	g_MCSCoder = new CMCSCoder ();

	/*
	 *	Make sure the creation of the packet coder was successful before
	 *	proceeding.
	 */
	if (g_MCSCoder == NULL)
	{
		/*
		 *	If the packet coder could not be createdm then report the error.
		 *	This IS a fatal error, so the faulty controller should be
		 *	destroyed and never used.
		 */
		WARNING_OUT (("Controller::Controller: failure creating packet coder"));
		*mcs_error = MCS_ALLOCATION_FAILURE;
	}

	/*
	 *	Do not continue with the initialization if an error has occured.
	 */
	if (*mcs_error == MCS_NO_ERROR)
	{
		// We have to initialize the User class
		if (FALSE == User::InitializeClass()) {
			/*
			 *	The initialization of the User class failed, so we
			 *	must fail the creation of this controller.
			 */
			WARNING_OUT (("Controller::Controller: "
					"failed to initialize User class."));
			*mcs_error = MCS_ALLOCATION_FAILURE;
		}
	}

	/*
	 *	Do not continue with the initialization if an error has occured.
	 */
	if (*mcs_error == MCS_NO_ERROR)
	{
		/*
		 *	We must allocate an event object that will used to notify the
		 *	controller when data is ready to be transmitted to a transport
		 *	stack.
		 */
		Transport_Transmit_Event = CreateEvent (NULL, FALSE, FALSE, NULL);

		if (Transport_Transmit_Event == NULL)
		{
			/*
			 *	Were unable to allocate an event object for this task, so we
			 *	must fail the creation of this controller.
			 */
			WARNING_OUT (("Controller::Controller: "
					"failure allocating transport transmit event object"));
			*mcs_error = MCS_ALLOCATION_FAILURE;
		}
	}

	/*
	 *	Do not continue with the initialization if an error has occured.
	 */
	if (*mcs_error == MCS_NO_ERROR)
	{
		/*
		 *	We must allocate an event object that will used for 
		 *	synchronization between the event loop thread and the thread 
		 *	that creates/destroys the Controller object.
		 */
		Synchronization_Event = CreateEvent (NULL, FALSE, FALSE, NULL);

		if (Synchronization_Event == NULL)
		{
			/*
			 *	Were unable to allocate an event object for this task, so we
			 *	must fail the creation of this controller.
			 */
			WARNING_OUT (("Controller::Controller: "
					"failure allocating synchronization event object"));
			*mcs_error = MCS_ALLOCATION_FAILURE;
		}
	}

	/*
	 *	Do not continue with the initialization if an error has occured.
	 */
	if (*mcs_error == MCS_NO_ERROR)
	{
		/*
		 *	We must allocate an event object that will used to notify the
		 *	controller when data is ready to be transmitted to a transport
		 *	stack.
		 */
		Connection_Deletion_Pending_Event = CreateEvent (NULL, FALSE, FALSE, NULL);

		if (Connection_Deletion_Pending_Event == NULL)
		{
			/*
			 *	Were unable to allocate an event object for this task, so we
			 *	must fail the creation of this controller.
			 */
			WARNING_OUT (("Controller::Controller: "
					"failure allocating connection deletion pending event object"));
			*mcs_error = MCS_ALLOCATION_FAILURE;
		}
	}

	/*
	 *	Do not continue with the initialization if an error has occured.
	 */
	if (*mcs_error == MCS_NO_ERROR)
	{
		/*
		 *	Initialize the flag that indicates that the controller is not yet
		 *	shutting down.
		 */
		Controller_Closing = FALSE;

		/*
		 *	Since everything else was successful, we must create a thread
		 *	winthin which the controller will do most of its work.
		 */
		g_hMCSThread = CreateThread (NULL, 0, ControllerThread,
				(PVoid) this, 0, &thread_id);

		if (g_hMCSThread == NULL)
		{
			/*
			 *	We were unable to create the thread that the controller needs
			 *	to do its job in an event-driven fashion.  We must therefore
			 *	fail the creation of this controller.
			 */
			WARNING_OUT (("Controller::Controller: failure creating thread"));
			*mcs_error = MCS_ALLOCATION_FAILURE;
		}
	}

	if (*mcs_error == MCS_NO_ERROR) {
		// We need to wait until the event loop thread creates the TCP msg window.
		WaitForSingleObject (Synchronization_Event, INFINITE);
		if (TCP_Window_Handle == NULL) {
			WARNING_OUT (("Controller::Controller: The event-loop thread failed to create the TCP msg window."));
			*mcs_error = MCS_NO_TRANSPORT_STACKS;

			/*
			 *	We assume that the event loop thread has exited.
			 */
			ClosePh (&g_hMCSThread);
		}
		else {
			/*
			 *	We set the flag used by the destructor
			 *	to check whether we should wait for the thread to finish.
			 */
			m_fControllerThreadActive = TRUE;
		}
	}

        if (*mcs_error == MCS_NO_ERROR)
	{
            g_CNPCoder = new CCNPCoder();
            if (g_CNPCoder != NULL) 
            {
                g_CNPCoder->Init();
            }
            else
            {
                WARNING_OUT(("Controller::Controller: "
                             "failuer allocating CNP Coder"));
                *mcs_error = MCS_ALLOCATION_FAILURE;
            }			
	}
        
	/*
	 *	Now, load the transport interface.
	 */
	if (*mcs_error == MCS_NO_ERROR)
	{
		DBG_SAVE_FILE_LINE
		g_Transport = new TransportInterface (Transport_Transmit_Event, 
													&transport_interface_error);

		/*
		 *	Make sure the creation of the object was successful before
		 *	proceeding.
		 */
		if (g_Transport != NULL)
		{
			/*
			 *	Check the return value from the constructor.
			 */
			if (transport_interface_error == TRANSPORT_INTERFACE_NO_ERROR)
			{
				/*
				 *	If everything was successful, put the new transport
				 *	interface object into the dictionary.
				 */
				WARNING_OUT (("Controller::Controller: "
						"TCP transport interface has been created successfully."));
			}
			else
			{
				/*
				 *	If the return value indicates that something went
				 *	wrong during the creation of the transport interface
				 *	object, then must destroy it immediately to insure
				 *	that it does not get used.
				 */
				WARNING_OUT (("Controller::Controller: "
						"deleting faulty TCP transport interface"));
				delete g_Transport;
				g_Transport = NULL;
				*mcs_error = MCS_NO_TRANSPORT_STACKS;
			}
		}
		else
		{
			/*
			 *	We were unable to create the transport interface object.
			 *	The MCS_NO_TRANSPORT_STACKS error is now a fatal error.
			 */
			WARNING_OUT (("Controller::Controller: "
					"failure allocating TCP transport interface"));
			*mcs_error = MCS_NO_TRANSPORT_STACKS;
		}
	}
}

/*
 *	~Controller ()
 *
 *	Public
 *
 *	Functional Description:
 *		This is the destructor for the Controller.  It destroys all objects
 *		owned by the controller.  Note that it attempts to do this in a
 *		systematic way to facilitate cleanup shut down.  If first deletes
 *		connection objects, giving them the opportunity to send disconnects
 *		to both the local and remote domains.  Then it deletes the transport
 *		interfaces.  Next it deletes the user objects, giving them the
 *		opportunity to cleanly sever their attachments to both the user
 *		applications and the local domains.  Then it deletes the application
 *		interfaces (which should no longer be needed).  Lastly it deletes
 *		the domains, which should be empty as a result of all user attachments
 *		and MCS connections being destroyed.
 */
Controller::~Controller ()
{
	PConnection				lpConnection;
	PConnectionPending		lpConnectionPending;
	//PTransportInterface		lpTransportInterface;
	//PUser					lpUser;
	PDomain					lpDomain;

	/*
	 *	We need to wait for the mutex before destroying the controller.  Note
	 *	that we do not check the return value from the wait because we have to
	 *	destroy this object no matter what.
	 */
	EnterCriticalSection (&g_MCS_Critical_Section);
	
	/*
	 *	This code clears out the Connection List.  Here it necessary to delete
	 *	not only the connection objects, but also the connection information
	 *	structure which is maintained by the controller.
	 */
	m_ConnectionList2.Reset();
	while (NULL != (lpConnection = m_ConnectionList2.Iterate()))
	{
		delete lpConnection;
	}

	Connection_Deletion_Pending = FALSE;

	/*
	 *	Clear out the connection pending list.  This includes freeing up memory
	 *	that was allocated to hold the connection pending structure.
	 */
	while (NULL != (lpConnectionPending = m_ConnPendingList2.Get()))
	{
		delete lpConnectionPending;
	}

	/*
	 *	This code clears out the Domain List.  All domain objects are deleted.
	 */
	while (NULL != (lpDomain = m_DomainList2.Get()))
    {
		delete lpDomain;
	}

	if (m_fControllerThreadActive)
	{
		/*
		 *	Set the flag that indicates to the event loop thread that it is time to
		 *	die.  Then, we wait for the thread to terminate itself.
		 */
		Controller_Closing = TRUE;

		// Give the eventloop a chance to exit
		SetEvent(Connection_Deletion_Pending_Event);
	}

	// We can now leave MCS's critical section
	LeaveCriticalSection (&g_MCS_Critical_Section);

	/*
	 *	If a thread termination event was successfully created for this controller, we must
	 *	wait on it.
	 */
	if (m_fControllerThreadActive)
	{
		/*
		 *	If the DLL instance variable is NULL, the process is 
		 *	detaching from the DLL.  This is the abnormal termination
		 *	case (after a GPF, for example). In this case, the event
		 *	loop thread has already exited, and we should not wait for it.
		 */
		if (g_hDllInst != NULL)
			WaitForSingleObject (Synchronization_Event, INFINITE);
			
		CloseHandle (Synchronization_Event);
		//
		//  Relinquish the remainder of our time slice, to allow controller thread to exit.
		//
		Sleep(0);
	}

	// Now, we can delete MCS's critical section
	DeleteCriticalSection (&g_MCS_Critical_Section);

	// Delete the transport interface and the application interfaces
	delete g_Transport;
		
	/*
	 *	If an event object was successfully allocated for application interface
	 *	events, then destroy it.
	 */
	if (Transport_Transmit_Event != NULL)
		CloseHandle (Transport_Transmit_Event);

	/*
	 *	If an event object was successfully allocated for connection deletion pending
	 *	events, then destroy it.
	 */
	if (Connection_Deletion_Pending_Event != NULL)
		CloseHandle (Connection_Deletion_Pending_Event);
	
	/*
	 *	If there is a packet coder, then delete it here.
	 */
	delete g_MCSCoder;

	delete g_CNPCoder;
	// Cleanup the User class
	User::CleanupClass();
	
	// Free up the preallocated DataPacket objects.
	DataPacket::FreeMemoryPool ();

	g_pMCSController = NULL;
}

 /*
 *	ULong APIENTRY	ControllerThread ()
 *
 *	Public
 *
 *	Functional Description:
 */
ULong APIENTRY	ControllerThread (
						PVoid		controller_ptr)
{
		//BOOL    		bTcpOK;
		PController		pController = (PController) controller_ptr;
	/*
	 *	This is the "C" entry point for the controller thread.  All it does is
	 *	use the address passed in to invoke the proper public member function of
	 *	the object that owns the thread.  All real work is done in the C++
	 *	member function.
	 */

	/* Set the New Thread's Priority. It's OK if the call fails.  */
	SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);

	pController->CreateTCPWindow ();
	SetEvent (pController->Synchronization_Event);

	if (TCP_Window_Handle != NULL) {
		// Initialize QoS
		CoInitialize(NULL);
		InitializeQoS();
		pController->EventLoop ();

		/*
		 *	Destroy the TCP window.  Since we are here, it has been created
		 *	successfully.
		 */
		pController->DestroyTCPWindow ();

		// Notify the Controller destructor that the thread exited
		SetEvent (pController->Synchronization_Event);

		// Cleanup QoS
		DeInitializeQoS();
		CoUninitialize();
	}
		
	return (0);
}


/*
 *	Void CreateTCPWindow ()
 *
 *	Private
 *
 *	Functional Description:
 *		This method registers the class of the TCP window and creates it.
 *
 *	Returns:
 *		TRUE, if successful. FALSE, otherwise
 */

Void Controller::CreateTCPWindow ()
{
	/*
	 *	Create the window and the resources needed by the transport
	 */
	WNDCLASS window_class = {
				0,					/* style */
				WindowProcedure,	/* lpfnWndProc */
				0,					/* cbClsExtra */
				0,					/* cbWndExtra */
				0,					/* hInstance */
				NULL,				/* hIcon */
				NULL,				/* hCursor */
				NULL,				/* hbrBackground */
				NULL,				/* lpszMenuName */
				MSMCSTCP_WINDOW_CLASS_NAME	/* lpszClassName */
			};

		/* Get the HINSTANCE for this Thread */
	window_class.hInstance = g_hDllInst;

	/* Register the hidden window's class */
	if(RegisterClass((const WNDCLASS *) (&window_class)) != 0) {
		TCP_Window_Handle = CreateWindow(
					MSMCSTCP_WINDOW_CLASS_NAME,	/* address of registered class name */
    				MSMCSTCP_WINDOW_CLASS_NAME,	/* address of window name */
    				WS_POPUP,					/* window style */
		    		CW_USEDEFAULT,				/* horizontal position of window */
    				CW_USEDEFAULT,				/* vertical position of window */
		    		CW_USEDEFAULT,				/* window width */
    				CW_USEDEFAULT,				/* window height */
		    		HWND(NULL),	       			/* handle of parent or owner window */
    				HMENU(NULL),				/* handle of menu */
		    		g_hDllInst,					/* handle of application instance */
    				LPVOID(NULL)); 				/* address of window-creation data */

		if(TCP_Window_Handle != NULL) {
#ifndef NO_TCP_TIMER
			/* Create a timer */
		    Timer_ID = SetTimer (TCP_Window_Handle, 0, 
               					(unsigned int) MSMCSTCP_TIMER_DURATION,
               					(TIMERPROC) NULL);
#endif	/* NO_TCP_TIMER */
		}
		else {
			WARNING_OUT (( "Controller::CreateTCPWindow: Error Creating %s", MSMCSTCP_WINDOW_CLASS_NAME));
		}
	}
	else {
		WARNING_OUT (( "Controller::CreateTCPWindow: Error Registering %s",MSMCSTCP_WINDOW_CLASS_NAME));
	}
}



/*
 *	Void DestroyTCPWindow ()
 *
 *	Private
 *
 *	Functional Description:
 *		This method destroys the TCP window and its class.
 *
 */

Void Controller::DestroyTCPWindow ()
{
	/*
	 *	This code clears out the TCP Transport interface.
	 */
	if (TCP_Window_Handle != NULL) {
		TRACE_OUT(("Controller::DestroyTCPWindow: Destroying TCP window..."));
#ifndef NO_TCP_TIMER
	    if (Timer_ID != 0)
    		KillTimer (TCP_Window_Handle, Timer_ID);
#endif	/* NO_TCP_TIMER */
		if(DestroyWindow (TCP_Window_Handle) == FALSE)
		{
			WARNING_OUT (("Controller::DestroyTCPWindow: Error Destroying %s", MSMCSTCP_WINDOW_CLASS_NAME));
		}
			
		/* Unregister the Window Class */
		if(UnregisterClass(MSMCSTCP_WINDOW_CLASS_NAME, g_hDllInst) == FALSE)
		{
			WARNING_OUT (("Controller::DestroyTCPWindow: Error Unregistering %s",	MSMCSTCP_WINDOW_CLASS_NAME));
		}
	}
}

/*
 *	Void	EventLoop ()
 *
 *	Public
 *
 *	Functional Description:
 */
Void	Controller::EventLoop ()
{
	HANDLE		event_list[NUMBER_OF_EVENTS];
	ULong		object_signaled;
	BOOL    	bFlushMoreData;
	MSG			msg;
	BOOL        fGCCWork;

    //
    // Externals from GCC.
    //
    extern HANDLE g_hevGCCOutgoingPDU;
    BOOL GCCRetryFlushOutgoingPDU ( void );

	/*
	 *	Set the initial timeout interval to infinite
	 */
	Controller_Wait_Timeout = INFINITE;
	Controller_Event_Mask = 0;

	/*
	 *	Set up the event list (this is used in the Wait call below).
	 */
	event_list[TRANSPORT_TRANSMIT_EVENT] = Transport_Transmit_Event;
	event_list[CONNECTION_DELETION_PENDING_EVENT] = Connection_Deletion_Pending_Event;
	event_list[GCC_FLUSH_OUTGOING_PDU_EVENT] = g_hevGCCOutgoingPDU;
	
	/*
	 *	Continue looping until this controller closes down.
	 */
	while (TRUE)
	{
		// Process the TCP window messages.
		while (PeekMessage (&msg, TCP_Window_Handle, 0, 0, PM_REMOVE)) {
			ASSERT (TCP_Window_Handle == msg.hwnd);
			EnterCriticalSection (&g_MCS_Critical_Section);
			DispatchMessage (&msg);
			LeaveCriticalSection (&g_MCS_Critical_Section);
		}

		/*
		 *	Go wait for something to happen (or for the timeout to expire,
		 *	which will cause us to poll for unfinished activity).
		 */
		object_signaled = MsgWaitForMultipleObjects (NUMBER_OF_EVENTS, event_list,
									FALSE, Controller_Wait_Timeout, QS_ALLINPUT);

        //
        // Default is that no GCC work needs to be done.
        //
        fGCCWork = FALSE;

		/*
		 *	Wait for the critical section to be available, before performing
		 *	any work on the event.
		 */
		EnterCriticalSection (&g_MCS_Critical_Section);
		
		if(Controller_Closing) {
			LeaveCriticalSection (&g_MCS_Critical_Section);
			break;
		}

		/*
		 *	Respond to the event dependent on which event occured.
		 */
		switch (object_signaled) {
		case WAIT_TIMEOUT:
		    fGCCWork = (Controller_Event_Mask & GCC_FLUSH_OUTGOING_PDU_MASK);
			/* 
			 *	We need to retry an operation.
			 */
			PollMCSDevices ();
			break;

		case WAIT_OBJECT_0 + CONNECTION_DELETION_PENDING_EVENT:
			/*
			 *	If a Connection object has asked to be deleted, then do it.
			 */
			while (Connection_Deletion_Pending)
			{
				CConnectionList2	Deletion_Pending_Copy(m_ConnectionDeletionList2);
				ConnectionHandle    connection_handle;
				PConnection			connection;

				Connection_Deletion_Pending = FALSE;
				while (NULL != (connection = Deletion_Pending_Copy.Get(&connection_handle)))
				{
					/*
					 *	Get the handle and pointer to the connection object to
					 *	be deleted.  Then remove it from both the connection
					 *	list, and the connection polling list.  Finally, delete
					 *	the connection object.
					 */
					m_ConnectionList2.Remove(connection_handle);
					m_ConnPollList.Remove(connection);
					delete connection;		// This could set the Connection_Deletion_Pending flag to TRUE
					m_ConnectionDeletionList2.Remove(connection_handle);
				}
				if (Connection_Deletion_Pending == FALSE)
				{
					m_ConnectionDeletionList2.Clear();
				}
			}
			break;

		case WAIT_OBJECT_0 + TRANSPORT_TRANSMIT_EVENT:
			/*
			 *	Iterate through the poll list, asking each connection to
			 *	flush any queued messages.
			 */
			PConnection lpConnection;

			bFlushMoreData = FALSE;
			Domain_Traffic_Allowed = TRUE;
			m_ConnPollList.Reset();
			while (NULL != (lpConnection = m_ConnPollList.Iterate()))
			{
				 if (lpConnection->FlushMessageQueue ()) {
				 	bFlushMoreData = TRUE;

				 	/*
				 	 *	We have flushed the connection, but it has more to send to 
				 	 *	the other end. Normally, we will get an FD_WRITE that allows
				 	 *	us to resume sending the queued data and will set this event
				 	 *	again to allow more sending. However, there is a special case
				 	 *	when the domain traffic is disallowed while a connection is
				 	 *	coming up.  For this case, the timeout has to be small, and
				 	 *	we need to set the Domain_Traffic_Allowed variable to 
				 	 *	distinguish between the two cases.
				 	 */
				 	Domain_Traffic_Allowed &= lpConnection->IsDomainTrafficAllowed();
				 }
			}
			UpdateWaitInfo (bFlushMoreData, TRANSPORT_TRANSMIT_INDEX);
			break;

		case WAIT_OBJECT_0 + GCC_FLUSH_OUTGOING_PDU_EVENT:
		    fGCCWork = TRUE;
		    break;
		}

		// Leave the MCS critical section
		LeaveCriticalSection (&g_MCS_Critical_Section);

        //
        // GCC work is done here WITHOUT MCS critical section.
        // The order of critical section in T120 is always GCC in front of MCS.
        // If we enter MCS here and enter GCC later in GCCRetryFlushOutgoingPDU(),
        // then we introduce a potential deadlock.
        //
        if (fGCCWork)
        {
            ASSERT(WAIT_TIMEOUT == object_signaled ||
                   (WAIT_OBJECT_0 + GCC_FLUSH_OUTGOING_PDU_EVENT) == object_signaled);

            bFlushMoreData = GCCRetryFlushOutgoingPDU();

            UpdateWaitInfo (bFlushMoreData, GCC_FLUSH_OUTGOING_PDU_INDEX);
        }
	}
}


/*
 *	Controller::UpdateWaitInfo ()
 *
 *	Private Function Description
 *		This routine updates the instance variables Controller_Wait_Timeout
 *		and Controller_Event_Mask after the processing of an event
 *		in the EventLoop.
 *
 *	Formal Parameters:
 *		bMoreData	-	(i)	Flag that informs us whether the msg flush										that holds a GCC conference query 
 *							triggered by the event was complete or left msgs
 *							unprocessed
 *		EventMask	-	(i)	Tells us which event was processed
 *
 *	Return Value
 *		None
 *
 *  Side Effects
 *		Controller_Event_Mask and Controller_Wait_Timeout are updated
 *
 *	Caveats
 *		None
 */

Void Controller::UpdateWaitInfo (
					BOOL    		bMoreData,
					unsigned int	index)
{
	if (bMoreData) {
		Controller_Event_Mask |= (0x1 << index);
	}
	else {
		if (0 != Controller_Event_Mask)
			Controller_Event_Mask &= ~(0x1 << index);
	}
	
	if (0 == Controller_Event_Mask)
		Controller_Wait_Timeout = INFINITE;
	else if (Controller_Event_Mask & TRANSPORT_MASK) {
		if ((Controller_Event_Mask & TRANSPORT_TRANSMIT_MASK) &&
			 (Domain_Traffic_Allowed == FALSE))
			Controller_Wait_Timeout = CONTROLLER_THREAD_TIMEOUT;
		else if (Controller_Event_Mask & TRANSPORT_RECEIVE_MASK)
			Controller_Wait_Timeout = TRANSPORT_RECEIVE_TIMEOUT;
		else
			Controller_Wait_Timeout = TRANSPORT_TRANSMIT_TIMEOUT;
	}
	else
		Controller_Wait_Timeout = CONTROLLER_THREAD_TIMEOUT;
}

/*
 *	ULong	OwnerCallback ()
 *
 *	Public
 *
 *	Functional Description:
 *		This is the owner callback entry function for the controller.  It is
 *		through this function that all of the controller's "children" make
 *		requests of the controller.  Rather than put a lot of otherwise
 *		unrelated code in one place, this function merely unpacks the
 *		parameters and sends them to a different private member function
 *		for each owner callback.
 *
 *		Sometimes the parameters are packed directly into the two long
 *		parameters, and sometimes one of the parameters is a pointer to a
 *		structure that contains more data.  This function takes care of that
 *		distinction, and passes the appropriate data along to each separate
 *		member function.
 */
void Controller::HandleTransportDataIndication
(
    PTransportData      pTransport_data
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    TransportDataIndication(pTransport_data->transport_connection,
                            pTransport_data->user_data,
                            pTransport_data->user_data_length);

    // We need to free up the transport buffer with the original data.
    FreeMemory(pTransport_data->memory);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);
}

void Controller::HandleTransportWaitUpdateIndication
(
    BOOL    fMoreData
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    /*
     *	We are setting ourselves to wake up again after some time
     *	because there has been a read message that could not allocate any
     *	buffers.
     */
    UpdateWaitInfo(fMoreData, TRANSPORT_RECEIVE_INDEX);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);
}

#ifdef NM_RESET_DEVICE
MCSError Controller::HandleAppletResetDevice
(
    PResetDeviceInfo    pDevInfo
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationResetDevice(pDevInfo->device_identifier);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}
#endif // NM_RESET_DEVICE

MCSError Controller::HandleAppletCreateDomain
(
    GCCConfID   *domain_selector
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationCreateDomain(domain_selector);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}

MCSError Controller::HandleAppletDeleteDomain
(
    GCCConfID   *domain_selector
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationDeleteDomain(domain_selector);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}

MCSError Controller::HandleAppletConnectProviderRequest
(
    PConnectRequestInfo pReqInfo
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationConnectProviderRequest(pReqInfo);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}

MCSError Controller::HandleAppletConnectProviderResponse
(
    PConnectResponseInfo pRespInfo
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationConnectProviderResponse(
                        pRespInfo->connection_handle,
                        pRespInfo->domain_selector,
                        pRespInfo->domain_parameters,
                        pRespInfo->result,
                        pRespInfo->user_data,
                        pRespInfo->user_data_length);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}

MCSError Controller::HandleAppletDisconnectProviderRequest
(
    ConnectionHandle    hConn
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationDisconnectProviderRequest(hConn);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}

MCSError Controller::HandleAppletAttachUserRequest
(
    PAttachRequestInfo  pReqInfo
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    MCSError rc = ApplicationAttachUserRequest(pReqInfo->domain_selector,
                                               pReqInfo->ppuser);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);

    return rc;
}

void Controller::HandleConnDeleteConnection
(
    ConnectionHandle    hConn
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    ConnectionDeleteConnection(hConn);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);
}

void Controller::HandleConnConnectProviderConfirm
(
    PConnectConfirmInfo pConfirmInfo,
    ConnectionHandle    hConn
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    ConnectionConnectProviderConfirm(hConn,
                                     pConfirmInfo->domain_parameters,
                                     pConfirmInfo->result,
                                     pConfirmInfo->memory);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);
}

void Controller::HandleTransportDisconnectIndication
(
    TransportConnection     TrnsprtConn,
    ULONG                  *pnNotify
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    TransportDisconnectIndication(TrnsprtConn);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);
}

#ifdef TSTATUS_INDICATION
void Controller::HandleTransportStatusIndication
(
    PTransportStatus    pStatus
)
{
    // Wait for the critical section before attempting any processing
    EnterCriticalSection(&g_MCS_Critical_Section);

    TransportStatusIndication(pStatus);

    // Release the critical section
    LeaveCriticalSection(&g_MCS_Critical_Section);
}
#endif


#ifdef NM_RESET_DEVICE
/*
 *	ULong	ApplicationResetDevice ()
 *
 *	Private
 *
 *	Functional Description:
 *		This function is used to send a reset command to a specified transport
 *		stack.  MCS performs no processing on this command except to pass it
 *		through.
 *
 *	Formal Parameters:
 *		device_identifier
 *			This is an ASCII string that is passed through to the transport
 *			stack to effect the reset.  It will typically contain information
 *			identifying which device within the stack is to be reset.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			Everything worked fine.
 *		MCS_INVALID_PARAMETER
 *			The specified transport stack does not exist.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
ULong	Controller::ApplicationResetDevice (
				PChar				device_identifier)
{
	TransportError			transport_error;
	MCSError				return_value;

	ASSERT (g_Transport != NULL);
	
	/*
	 *	Forward the reset device command to the transport interface
	 *	object.
	 */
	TRACE_OUT(("Controller::ApplicationResetDevice: "
				"sending ResetDevice to transport interface"));
	transport_error = g_Transport->ResetDevice (device_identifier);

	/*
	 *	Set the return value appropriate for the value returned from the
	 *	transport call.
	 */
	switch (transport_error)
	{
		case TRANSPORT_ILLEGAL_COMMAND:
			return_value = MCS_INVALID_PARAMETER;
			break;

		case TRANSPORT_MEMORY_FAILURE:
			return_value = MCS_ALLOCATION_FAILURE;
			break;

		default:
			return_value = MCS_NO_ERROR;
	}

	//
	// Remove this connection from the connection list
	//
	PConnection			connection;
	ConnectionHandle	connection_handle;

	while (NULL != (connection = m_ConnectionList2.Iterate(&connection_handle)))
	{
		if (0 == ::My_strcmpA(connection->GetCalledAddress(), device_identifier))
		{
			PNodeControllerMessage		node_controller_message;

			DBG_SAVE_FILE_LINE
			node_controller_message = new NodeControllerMessage;

			if (node_controller_message != NULL) {
				/*
				 *	Fill out the node controller message structure to indicate the
				 *	disconnect.
				 */
				node_controller_message->message_type =
							MCS_DISCONNECT_PROVIDER_INDICATION;
				node_controller_message->u.disconnect_provider_indication.
							connection_handle = (ConnectionHandle) connection_handle;
				node_controller_message->u.disconnect_provider_indication.
							reason = REASON_DOMAIN_DISCONNECTED;
				node_controller_message->memory = NULL;

				/*
				 *	Put the message into the control queue to be sent to the node
				 *	controller during the next heartbeat.
				 */
				AddToMessageQueue (node_controller_message);
			}
			else 
				ERROR_OUT (("Controller::ApplicationResetDevice: "
							"failed to allocate node controller msg"));
		}
	}

	return ((ULong) return_value);
}
#endif //NM_RESET_DEVICE


/*
 *	Controller::PollMCSDevices ()
 *
 *	Public Function Description
 *		This is the MCS controller's heartbeat. It will call the heartbeat
 *		equivalent functions for the Application SAPs, the connections and
 *		the users.
 */
Void	Controller::PollMCSDevices()
{
	BOOL    		bFlushMoreData;

	if (Controller_Event_Mask & TRANSPORT_TRANSMIT_MASK) {
		/*
		 *	Iterate through the poll list, asking each connection to
		 *	flush any queued messages.
		 */
		PConnection lpConnection;

		bFlushMoreData = FALSE;
		Domain_Traffic_Allowed = TRUE;
		m_ConnPollList.Reset();
		while (NULL != (lpConnection = m_ConnPollList.Iterate()))
		{
			 if (lpConnection->FlushMessageQueue ()) {
			 	bFlushMoreData = TRUE;

			 	/*
			 	 *	We have flushed the connection, but it has more to send to 
			 	 *	the other end. Normally, we will get an FD_WRITE that allows
			 	 *	us to resume sending the queued data and will set this event
			 	 *	again to allow more sending. However, there is a special case
			 	 *	when the domain traffic is disallowed while a connection is
			 	 *	coming up.  For this case, the timeout has to be small, and
			 	 *	we need to set the Domain_Traffic_Allowed variable to 
			 	 *	distinguish between the two cases.
			 	 */
			 	Domain_Traffic_Allowed &= lpConnection->IsDomainTrafficAllowed();
			 }
		}
		UpdateWaitInfo (bFlushMoreData, TRANSPORT_TRANSMIT_INDEX);			
	}

	if (Controller_Event_Mask & TRANSPORT_RECEIVE_MASK) {
		ASSERT (g_Transport);
		g_Transport->ReceiveBufferAvailable();
	}

}

/*
 *	MCSError	ApplicationCreateDomain ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request comes through one of the application interface objects.
 *		the only parameter is a domain selector.  If a domain with that
 *		selector does not currently exist, it will be created.
 *
 *		A domain must be created before user attachments or MCS connections can
 *		be created.
 *
 *	Formal Parameters:
 *		domain_selector (i)
 *			This is the domain selector for the new domain.
 *		domain_selector_length (i)
 *			This is the length of the above domain selector.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			The domain was successfully created.
 *		MCS_ALLOCATION_FAILURE
 *			A memory allocation failure prevented the successful creation of
 *			the new domain.
 *		MCS_DOMAIN_ALREADY_EXISTS
 *			The named domain already exists.
 *
 *	Side Effects:
 *		A logical domain now exists that can accomodate both user attachments
 *		and MCS connections.
 *
 *	Caveats:
 *		None.
 */
MCSError Controller::ApplicationCreateDomain
(
    GCCConfID      *domain_selector
)
{
	PDomain		domain;
	MCSError	return_value;

	/*
	 *	Check to see if the requested domain already exists.  If so, then
	 *	do not attempt to create a new one.  Just return the appropriate
	 *	return value.
	 */
	if (m_DomainList2.Find(*domain_selector) == FALSE)
	{
		/*
		 *	The next action is to instantiate a new domain object.  This
		 *	is initially an empty domain that will be associated with the
		 *	user provided domain selector.
		 */
		DBG_SAVE_FILE_LINE
		domain = new Domain ();
		if (domain != NULL)
		{
			/*
			 *	If everything was allocated successfully, then simply put
			 *	the new domain into the domain list dictionary.  and set the
			 *	return value to indicate success.
			 */
			TRACE_OUT (("Controller::ApplicationCreateDomain: "
					"domain creation successful"));
			if(!m_DomainList2.Append(*domain_selector, domain))
			{
				delete domain;
				return_value = MCS_ALLOCATION_FAILURE;
			}
			else
			{
				return_value = MCS_NO_ERROR;
			}
		}
		else
		{
			/*
			 *	Set the return value to indication a memory allocation failure.
			 */
			WARNING_OUT (("Controller::ApplicationCreateDomain: "
					"domain creation failed"));
			return_value = MCS_ALLOCATION_FAILURE;
		}
	}
	else
	{
		/*
		 *	The domain was not created since it already exists.
		 */
		WARNING_OUT (("Controller::ApplicationCreateDomain: "
				"domain already exists"));
		return_value = MCS_DOMAIN_ALREADY_EXISTS;
	}

	return (return_value);
}

/*
 *	MCSError	ApplicationDeleteDomain ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request comes from one of the application interface objects.  It
 *		instructs the controller to delete an existing domain, with the only
 *		parameter identifying the domain to be deleted.  If the domain exists,
 *		then it will be destroyed.
 *
 *		Note that all user attachments and MCS connections that are attached
 *		to the domain when it is deleted will also be deleted (automatically).
 *
 *	Formal Parameters:
 *		domain_selector (i)
 *			This is the domain selector for the domain to be deleted.
 *		domain_selector_length (i)
 *			This is the length of the above domain selector.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			The domain was successfully deleted.
 *		MCS_NO_SUCH_DOMAIN
 *			There is no domain associated with the passed in domain selector.
 *
 *	Side Effects:
 *		When the domain is deleted, all resources used by it (including user
 *		attachments and MCS connections) will be deleted as well.
 *
 *	Caveats:
 *		None.
 */
MCSError Controller::ApplicationDeleteDomain
(
    GCCConfID       *domain_selector
)
{
	PDomain		domain;
	MCSError	return_value;

	/*
	 *	Check to see if the domain selector refers to a valid domain.
	 */
	if (NULL != (domain = m_DomainList2.Remove(*domain_selector)))
	{
		/*
		 *	If the domain selector is valid, then remove the domain from the
		 *	dictionary and delete it.  Everything else happens automatically
		 *	as a result of destroying the domain object.
		 */
		TRACE_OUT (("Controller::ApplicationDeleteDomain: deleting domain"));
		delete domain;
		return_value = MCS_NO_ERROR;
	}
	else
	{
		/*
		 *	If the domain selector is not in the dictionary, then report the
		 *	error to the caller.
		 */
		ERROR_OUT (("Controller::ApplicationDeleteDomain: invalid domain"));
		return_value = MCS_NO_SUCH_DOMAIN;
	}

	return (return_value);
}

/*
 *	MCSError	ApplicationConnectProviderRequest ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates from one of the application interface objects.
 *		This happens as the result of the node controller issuing a
 *		ConnectProviderRequest to whichever application interface object
 *		that it is attached to.  If the parameters are valid, then a new
 *		connection object will be created to represent the outbound connection.
 *		This will result in the connection object calling the proper transport
 *		interface to create the transport connection, etc.
 *
 *	Formal Parameters:
 *		pcriConnectRequestInfo (i)
 *			Contains all the needed info to complete the Connect Provider Request.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			The request was successful.  The connection handle for the newly
 *			created connection has been stored at the address passed into this
 *			request (see parameter list above).  Note that this connection
 *			handle can be used to destroy the new connection immediately, even
 *			if the physical connection has not yet been established.  This
 *			allows the node controller to abort a dial in-progress by calling
 *			DisconnectProviderRequest.
 *		MCS_INVALID_PARAMETER
 *			The format of the called address field is incorrect.
 *		MCS_ALLOCATION_FAILURE
 *			The request was unable to complete successfully due to a memory
 *			allocation failure (either in MCS or the transport layer).
 *		MCS_TRANSPORT_NOT_READY
 *			The transport layer could not process the request because it is not
 *			ready.  This usually means that initialization has not successfully
 *			completed.
 *		MCS_DOMAIN_NOT_HIERARCHICAL
 *			This request is attempting to create an upward connection to a
 *			domain that already has an upward connection (which is not valid).
 *		MCS_NO_SUCH_DOMAIN
 *			The specified local domain does not exist within this provider.
 *
 *	Side Effects:
 *		An outbound connect establishment process is begun.
 *
 *	Caveats:
 *		None.
 */
MCSError Controller::ApplicationConnectProviderRequest (
						PConnectRequestInfo		pcriConnectRequestInfo)
{
	PDomain					domain;
	BOOL					bTransportIdFound;
	PConnection				connection;
	MCSError				return_value; 
	PChar					called_address = pcriConnectRequestInfo->called_address;
	PConnectionHandle		connection_handle = pcriConnectRequestInfo->connection_handle;

	/*
	 *	Make sure the local domain specified corresponds to an existing
	 *	domain.
	 */
	ASSERT(sizeof(GCCConfID) == sizeof(*(pcriConnectRequestInfo->calling_domain)));
	if (NULL != (domain = m_DomainList2.Find(*(pcriConnectRequestInfo->calling_domain))))
	{
		/*
		 *	Check to make sure that the requested connection is valid.
		 *	Specifically, make sure that this is not a request for an upward
		 *	connection to a domain that already has an upward connection.
		 *	This would result in a non-hierarchical domain, which is illegal.
		 */
		if ((pcriConnectRequestInfo->upward_connection == FALSE) || (domain->IsTopProvider ()))
		{
			PChar		pColon;
			/*
			 *	Look for the colon that separates the identifier from the
			 *	address.  
			 */

			for (bTransportIdFound = FALSE, pColon = called_address; *pColon; pColon++)
				if (*pColon == ':') {
					bTransportIdFound = TRUE;
					break;
				}

			/*
			 *	Make sure that there was a colon before continuing.
			 */
			if (bTransportIdFound)
			{
				ASSERT (g_Transport != NULL);
				
				called_address = pColon + 1;
				/*
				 *	Allocate an unused connection handle to be
				 *	associated with the new MCS connection.
				 */
				*connection_handle = AllocateConnectionHandle ();

				/*
				 *	Create a new connection object.  The constructor
				 *	parameters provide everything that the connection
				 *	object will need to create a new outbound MCS
				 *	connection.
				 */
				DBG_SAVE_FILE_LINE
				connection = new Connection (domain,
						*connection_handle, 
						pcriConnectRequestInfo->calling_domain, 
						pcriConnectRequestInfo->called_domain, 
						called_address, 
						pcriConnectRequestInfo->fSecure,
						pcriConnectRequestInfo->upward_connection, 
						pcriConnectRequestInfo->domain_parameters,
						pcriConnectRequestInfo->user_data, 
						pcriConnectRequestInfo->user_data_length, 
						&return_value);
				/*
				 *	Check to see if the allocation of the connection
				 *	worked.
				 */
				if (connection != NULL)
				{
					/*
					 *	Even if the connection object was allocated
					 *	successfully, it is still possible that an error
					 *	occurred while it was trying to initialize.  So
					 *	check the return value from the contructor.
					 */
					if (return_value == MCS_NO_ERROR)
					{
						/*
						 *	Put the connection into the connection list
						 *	dictionary.
						 */
						TRACE_OUT (("Controller::ApplicationConnectProviderRequest: "
									"new connection created"));
						m_ConnectionList2.Insert(*connection_handle, connection);
						m_ConnPollList.Append(connection);
					}
					else
					{
						/*
						 *	If the connection object was successfully
						 *	allocated, but its initialization failed,
						 *	then it is necessary to destroy the faulty
						 *	connection and return the appropriate error
						 *	to the caller.
						 */
						WARNING_OUT (("Controller::ApplicationConnectProviderRequest: "
									"deleting faulty connection"));
						delete connection;
					}
				}
				else
				{
					/*
					 *	The allocation of the connection object has
					 *	failed.  Simply return the appropriate error and
					 *	abort the request.
					 */
					WARNING_OUT (("Controller::ApplicationConnectProviderRequest: "
								"connection allocation failed"));
					return_value = MCS_ALLOCATION_FAILURE;
				}

				// Put back the colon in the "called_address"  
				*pColon = ':';
			}
			else
			{
				/*
				 *	There was not a colon in the called address, so MCS has
				 *	no way of extracting the transport identifier.  The request
				 *	must therefore fail.
				 */
				ERROR_OUT (("Controller::ApplicationConnectProviderRequest: "
						"no colon in called address"));
				return_value = MCS_INVALID_PARAMETER;
			}
		}
		else
		{
			/*
			 *	The domain already has an upward connection (or one pending).
			 *	This request is therefore invalid and must be rejected.
			 */
			ERROR_OUT (("Controller::ApplicationConnectProviderRequest: "
					"domain not hierarchical"));
			return_value = MCS_DOMAIN_NOT_HIERARCHICAL;
		}
	}
	else
	{
		/*
		 *	If the local domain selector does not correspond to a valid
		 *	domain in this provider, then fail the request immediately by
		 *	returning the appropriate error.
		 */
		ERROR_OUT (("Controller::ApplicationConnectProviderRequest: "
				"invalid local domain"));
		return_value = MCS_NO_SUCH_DOMAIN;
	}

	return (return_value);
}

/*
 *	MCSError	ApplicationConnectProviderResponse ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates from one of the application interface objects.
 *		This happens as the result of the node controller issuing a
 *		ConnectProviderResponse to whichever application interface object
 *		that it is attached to.  If the connection handle is valid, and the
 *		local domain still exists, then that domain will be told whether or not
 *		the incoming connection was accepted.  This allows it to repsond
 *		appropriately.
 *
 *	Formal Parameters:
 *		connection_handle (i)
 *			This identifies the connection from which a previous connect
 *			provider indication originated.  This request essentially states
 *			whether or not this incoming connection is accepted.
 *		domain_selector (i)
 *			This is the domain selector of the domain that the node controller
 *			wishes to bind the incoming connection to.
 *		domain_selector_length (i)
 *			This is the length of the above domain selector.
 *		domain_parameters (i)
 *			This is a pointer to a structure containing the domain parameters
 *			that the node controller wishes to use for this connection.
 *		result (i)
 *			This is the result to be sent to the remote provider.  Coming
 *			from the node controller this should be either RESULT_SUCCESSFUL
 *			or RESULT_USER_REJECTED.  If it is anything but RESULT_SUCCESSFUL,
 *			the associated connection will be immediately destroyed.
 *		user_data (i)
 *			This is the address of the user data that is to be sent in the
 *			connect response PDU to the remote provider.
 *		user_data_length (i)
 *			This is the length of the user data to be sent in the connect
 *			response PDU to the remote provider.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			The response was sent to the appropriate domain successfully.
 *		MCS_DOMAIN_PARAMETERS_UNACCEPTABLE
 *			This indicates that there is no overlap in the min and max
 *			parameters specified by the remote node, and the min and max
 *			parameters acceptable to the specified domain.  Therefore, no
 *			connection is possible.  This does NOT indicate that there is
 *			anything wrong with the specified target parameters (which are
 *			just suggested values anyway).
 *		MCS_ALLOCATION_FAILURE
 *			The response failed due to a memory allocation failure.
 *		MCS_NO_SUCH_DOMAIN
 *			This indicates that the domain associated with the pending
 *			response has been deleted since the indication was sent.
 *		MCS_NO_SUCH_CONNECTION
 *			This indicates that the connection has been lost since the
 *			indication was issued.
 *		MCS_DOMAIN_NOT_HIERARCHICAL
 *			This request is attempting to create an upward connection to a
 *			domain that already has an upward connection (which is not valid).
 *
 *	Side Effects:
 *		If the response is other than RESULT_SUCCESSFUL, the transport
 *		connection that conveys the connect response PDU will be severed.
 *
 *	Caveats:
 *		None.
 */
MCSError Controller::ApplicationConnectProviderResponse (
				ConnectionHandle		connection_handle,
				GCCConfID              *domain_selector,
				PDomainParameters		domain_parameters,
				Result					result,
				PUChar					user_data,
				ULong					user_data_length)
{
	PConnectionPending		connection_pending;
	TransportConnection		transport_connection;
	BOOL    				upward_connection;
	PDomain					domain;
	PConnection				connection;
	MCSError				return_value;

	/*
	 *	Check to see if the connection handle corresponds to a connection
	 *	that is awaiting a response.
	 */
	if (NULL != (connection_pending = m_ConnPendingList2.Find(connection_handle)))
	{
		/*
		 *	Get the address of the structure containing information about the
		 *	pending connection.  Then load the contained information into
		 *	automatic variables for easier manipulation.
		 */
		transport_connection = connection_pending->transport_connection;
		upward_connection = connection_pending->upward_connection;
		if (domain_parameters == NULL)
			domain_parameters = &connection_pending->domain_parameters;

		/*
		 *	See if the node controller has elected to accept or reject the
		 *	incoming connection.  If it is accepted, then the response must
		 *	be sent through the appropriate domain object.  If it is
		 *	rejected, then the response can be sent directly to the
		 *	connection object (which will then delete itself).
		 */
		if (result == RESULT_SUCCESSFUL)
		{
			/*
			 *	See if the specified domain is valid, before trying to send
			 *	the response to it.
			 */
			if (NULL != (domain = m_DomainList2.Find(*domain_selector)))
			{
				/*
				 *	Check to make sure that the requested connection is valid.
				 *	Specifically, make sure that this is not a request for an
				 *	upward connection to a domain that already has an upward
				 *	connection.  This would result in a non-hierarchical domain,
				 *	which is illegal.
				 */
				if ((upward_connection == FALSE) || (domain->IsTopProvider ()))
				{
					/*
					 *	Create the connection object that will be responsible
					 *	for the inbound connection.  It will automatically issue
					 *	a ConnectResponse during construction.
					 */
					DBG_SAVE_FILE_LINE
					connection = new Connection (domain, 
							connection_handle, transport_connection, 
							upward_connection, domain_parameters,
							&connection_pending->minimum_domain_parameters,
							&connection_pending->maximum_domain_parameters,
							user_data, user_data_length,
							&return_value);

					if (connection != NULL)
					{
						if (return_value == MCS_NO_ERROR)
						{
							/*
							 *	Everything worked fine.  Remove the connection
							 *	handle from the pending list, and put the newly
							 *	created connection object into the active
							 *	connection list.
							 */
							TRACE_OUT(("Controller::ApplicationConnectProviderResponse: "
									"connection created successfully"));
							m_ConnPendingList2.Remove(connection_handle);
							delete connection_pending;
							m_ConnectionList2.Insert(connection_handle, connection);
							m_ConnPollList.Append(connection);
						}
						else
						{
							/*
							 *	The contructor failed, which probably indicates
							 *	an allocation failure.  Report this to the node
							 *	controller, and delete the faulty connection
							 *	object.
							 */
							WARNING_OUT (("Controller::ApplicationConnectProviderResponse: "
									"connection constructor failed"));
							delete connection;
						}
					}
					else
					{
						/*
						 *	The allocation failed.  Report this to the node
						 *	controller.
						 */
						WARNING_OUT (("Controller::ApplicationConnectProviderResponse: "
								"connection constructor failed"));
						return_value = MCS_ALLOCATION_FAILURE;
					}
				}
				else
				{
					/*
					 *	The domain already has an upward connection (or one
					 *	pending).  This request is therefore invalid and must be
					 *	rejected.
					 */
					ERROR_OUT (("Controller::ApplicationConnectProviderResponse:"
							" domain not hierarchical"));
					return_value = MCS_DOMAIN_NOT_HIERARCHICAL;
				}
			}
			else
			{
				/*
				 *	If the indicated domain is not valid, then simply return
				 *	the appropriate error.
				 */
				WARNING_OUT (("Controller::ApplicationConnectProviderResponse: "
						"invalid domain"));
				return_value = MCS_NO_SUCH_DOMAIN;
			}
		}
		else
		{
			/*
			 *	The node controller has elected to reject the incoming
			 *	connection.  It is therefore not necessary to create a
			 *	connection object.  Send the connect response directly to
			 *	the transport interface object, and then disconnect the
			 *	transport connection.
			 */
			TRACE_OUT (("Controller::ApplicationConnectProviderResponse: connection rejected"));

			ASSERT (g_Transport);
			ConnectResponse (transport_connection, result, 
						domain_parameters, 0, user_data, user_data_length);

			g_Transport->DisconnectRequest (transport_connection);

			/*
			 *	Remove the connection handle from the pending list, and
			 *	delete the structure that was holding information about
			 *	the pending connection.
			 */
			m_ConnPendingList2.Remove(connection_handle);
			delete connection_pending;
			return_value = MCS_NO_ERROR;
		}
	}
	else
	{
		/*
		 *	If the connection handle is no longer valid, then fail the request
		 *	with the appropriate error.
		 */
		WARNING_OUT (("Controller::ApplicationConnectProviderResponse: "
				"invalid connection"));
		return_value = MCS_NO_SUCH_CONNECTION;
	}

	return (return_value);
}

/*
 *	MCSError	ApplicationDisconnectProviderRequest ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates from one of the application interface objects.
 *		This happens as the result of the node controller issuing a
 *		DisconnectProviderRequest to whichever application interface object
 *		that it is attached to.  If the connection handle is valid, then the
 *		connection object wil be destroyed, which will break the transport
 *		connections associated with it.
 *
 *	Formal Parameters:
 *		connection_handle (i)
 *			This identifies the connection to be destroyed.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			The named connection has been successfully deleted.
 *		MCS_NO_SUCH_CONNECTION
 *			The connection handle is invalid.
 *
 *	Side Effects:
 *		One or more transport connections will be broken.  Furthermore, if
 *		this is an upward connection for a domain, then the domain itself
 *		will be eradicated (all attachments and connections will be severed).
 *
 *	Caveats:
 *		None.
 */
MCSError Controller::ApplicationDisconnectProviderRequest (
				ConnectionHandle		connection_handle)
{
	MCSError				return_value;
	PConnection				connection;
	PConnectionPending		connection_pending;

	/*
	 *	Check to see if the connection handle refers to an existing connection.
	 */
	if (NULL != (connection = m_ConnectionList2.Find(connection_handle)))
	{
		/*
		 *	If the connection handle is valid, then delete the associated
		 *	connection and remove it from the connection dictionary.  It is also
		 *	necessary to delete the connection information structure.
		 */
		TRACE_OUT (("Controller::ApplicationDisconnectProviderRequest: "
				"deleting connection"));
		m_ConnectionList2.Remove(connection_handle);
		m_ConnPollList.Remove(connection);
		delete connection;

		/*
		 *	Check to see if this connection handle is also in the connection
		 *	deletion list.  If so, then remove it from there as well.
		 */
		m_ConnectionDeletionList2.Remove(connection_handle);

		return_value = MCS_NO_ERROR;
	}

	else if (NULL != (connection_pending = m_ConnPendingList2.Remove(connection_handle)))
	{
		/*
		 *	This connection handle refers to a connection that is still
		 *	pending.  Delete it from there.
		 */
		WARNING_OUT (("Controller::ApplicationDisconnectProviderRequest: "
				"deleting pending connection"));
		delete connection_pending;

		return_value = MCS_NO_ERROR;
	}
	else
	{
		/*
		 *	If the connection handle is not in either of the above dictionaries,
		 *	then return the appropriate error.
		 */
		TRACE_OUT (("Controller::ApplicationDisconnectProviderRequest: "
				"invalid connection"));
		return_value = MCS_NO_SUCH_CONNECTION;
	}

	return (return_value);
}

/*
 *	MCSError	ApplicationAttachUserRequest ()
 *
 *	Private
 *
 *	Functional Description:
 *		This function is used to attach a user application to an existing
 *		domain.  The user handle that is returned can then be used by the
 *		application to request services from MCS.
 *
 *		After verifying that the specified domain really does exist, the
 *		controller will create a new user object.  The new user object will
 *		attach itself to both the domain and the application interface
 *		specified by the controller.  At that point, information can flow
 *		through the application interface to the user and then on to the
 *		domain without having to pass through the controller.
 *
 *	Formal Parameters:
 *		domain_selector (i)
 *			This identifies the domain to which the user wants to attach.
 *		domain_selector_length (i)
 *			This is the length of the above domain selector.
 *		attachment_flags (i)
 *			This is a set of flags that allow the user application to control
 *			how the attachment is handled.  The only flag currently used by
 *			the controller specifies whether or not the user wants to receive
 *			callbacks during the controller's heartbeat.
 *		ppUser (o)
 *			This is a pointer to a user handle, which will be set to a valid
 *			value by the controller if this function completes successfully.
 *			The user handle is really a pointer to a User object.
 *
 *	Return Value:
 *		MCS_NO_ERROR
 *			Everything completed successfully.  Note that the attachment
 *			cannot actually be used by the user application until it has
 *			received a successful attach user confirm from the domain to
 *			which it has attached.  This return value merely indicates that
 *			process was started successfully.
 *		MCS_ALLOCATION_FAILURE
 *			This attach request was unable to successfully complete due to a
 *			memory allocation failure.
 *		MCS_NO_SUCH_DOMAIN
 *			This attach request was unable to successfully complete because
 *			the specified domain does not exist within this provider.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
MCSError Controller::ApplicationAttachUserRequest
(
    GCCConfID       *domain_selector,
    PUser           *ppUser
)
{
	MCSError	return_value;
	PDomain		domain;

	/*
	 *	First of all make sure that the domain selector refers to a valid
	 *	domain.  If it doesn't, then return the appropriate error.
	 */
	if (NULL != (domain = m_DomainList2.Find(*domain_selector)))
	{
		/*
		 *	Instantiate a new user object, with the domain and the application
		 *	interface pointer as parameters.
		 */
		DBG_SAVE_FILE_LINE
		*ppUser = (PUser) new User (domain, &return_value);

		/*
		 *	Make sure the allocation completed successfully
		 */
		if (*ppUser != NULL) {
			/*
			 *	The creation of the user object was successful.
			 */
			if (return_value != MCS_NO_ERROR) {
				// We have to cleanup the object.
				(*ppUser)->Release();
			}
		}
		else {
			/*
			 *	There was a memory allocation failure, so return the
			 *	appropriate error.
			 */
			WARNING_OUT (("Controller::ApplicationAttachUserRequest: "
					"user creation failed"));
			return_value = MCS_ALLOCATION_FAILURE;
		}
	}
	else
	{
		/*
		 *	The specified domain does not exist, so return the appropriate
		 *	error.
		 */
		WARNING_OUT (("Controller::ApplicationAttachUserRequest: invalid domain"));
		return_value = MCS_NO_SUCH_DOMAIN;
	}

	return (return_value);
}

/*
 *	Void	ConnectionDeleteConnection ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates within a connection object when it determines
 *		the need to delete itself.  This is usually caused by one of three
 *		things.  First, the connection was rejected (inbound or outbound).
 *		Second, either the local or remote domain issued a disconnect
 *		provider ultimatum.  Or third, a transport connection was unexpectedly
 *		lost.
 *
 *		The controller responds by deleting the connection, after the
 *		parameters are validated.  It also issues a disconnect provider
 *		indication to the node controller.
 *
 *	Formal Parameters:
 *		connection_handle (i)
 *			This is the handle of the connection object that wishes to be
 *			deleted.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		An MCS connection is terminated, which may result in the destruction
 *		of one or more transport connections.
 *
 *	Caveats:
 *		None.
 */
Void	Controller::ConnectionDeleteConnection (
					ConnectionHandle    connection_handle)
{
	PConnection					connection;

	/*
	 *	Make sure the connection handle is in the dictionary before proceeding.
	 */
	if (NULL != (connection = m_ConnectionList2.Find(connection_handle)))
	{
		/*
		 *	See if the deletion of this connection is already pending.  If so,
		 *	there is no need to queue it up again.
		 */
		if (! m_ConnectionDeletionList2.Find(connection_handle))
		{
			/*
			 *	Put the connection object into the deletion list and set the
			 *	deletion pending flag.
			 */
			TRACE_OUT (("Controller::ConnectionDeleteConnection: "
					"adding connection to deletion list"));
			m_ConnectionDeletionList2.Insert(connection_handle, connection);
			Connection_Deletion_Pending = TRUE;
			SetEvent(Connection_Deletion_Pending_Event);

			/*
			 *	Post the message to the controller window (GCC and MCS
			 *	use the same window to post messages to their controllers).
			 */
			if (! PostMessage (g_pControlSap->GetHwnd(), 
							MCTRLMSG_BASE + MCS_DISCONNECT_PROVIDER_INDICATION,
							NULL, (LPARAM) connection_handle)) {
				ERROR_OUT(("Controller::ConnectionDeleteConnection: "
							"failed to post msg to MCS controller window. Error: %d", GetLastError()));
			}
		}
	}
	else
	{
		/*
		 *	If the connection handle cannot be found in the connection
		 *	dictionary, then simply ignore the request.
		 */
		WARNING_OUT (("Controller::ConnectionDeleteConnection: "
				"unknown connection"));
	}
}

/*
 *	Void	ConnectionConnectProviderConfirm ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates within a domain object upon reception of a
 *		connect response PDU.  The controller responds by sending a connect
 *		provider confirm to the node controller.
 *
 *	Formal Parameters:
 *		connection_handle (i)
 *			This is the handle of the connection object from which the connect
 *			provider confirm was received.
 *		domain_parameters (i)
 *			This is a pointer to a structure that contains the domain parameters
 *			that were decided on during capabilities arbitration.
 *		result (i)
 *			This contains the result of the connect request.  Anything but
 *			RESULT_SUCCESSFUL means that the connection was rejected.
 *		memory (i)
 *			If this is not NULL, it contains the user data that was received
 *			in the connect response PDU.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		A connect provider confirm is sent to the node controller.
 *
 *	Caveats:
 *		None.
 */
void	Controller::ConnectionConnectProviderConfirm (
				ConnectionHandle		connection_handle,
				PDomainParameters		domain_parameters,
				Result					result,
				PMemory					memory)
{
	PConnection					connection;
	PUChar						user_data;
	ULong						user_data_length;
	ConnectProviderConfirm		*pconnect_provider_confirm;

	/*
	 *	Make sure the connection handle is in the dictionary before proceeding.
	 */
	if (NULL != (connection = m_ConnectionList2.Find(connection_handle)))
	{
		// Allocate the node controller msg.
		DBG_SAVE_FILE_LINE
		pconnect_provider_confirm = new ConnectProviderConfirm;

		if (pconnect_provider_confirm != NULL) {
			/*
			 *	Check to see if there is user data associated with this confirm.
			 */
			if (memory != NULL)
			{
				/*
				 *	If there is user data, lock it, and get the address and length
				 *	into temporary variables.
				 */
				LockMemory (memory);
				user_data = memory->GetPointer ();
				user_data_length = memory->GetLength ();
			}
			else
			{
				/*
				 *	If there is no user data, then set the address and length fields
				 *	to default values.
				 */
				user_data = NULL;
				user_data_length = 0;
			}

			/*
			 *	Put all information about this confirm into the node controller
			 *	message structure allocated above.
			 */
			pconnect_provider_confirm->connection_handle = (ConnectionHandle) connection_handle;
			pconnect_provider_confirm->domain_parameters = *domain_parameters;
			pconnect_provider_confirm->result = result;
			pconnect_provider_confirm->user_data = user_data;
			pconnect_provider_confirm->user_data_length = user_data_length;
			pconnect_provider_confirm->pb_cred = NULL;
			pconnect_provider_confirm->cb_cred = 0;

			DWORD cb = 0;
			if (GetSecurityInfo(connection_handle, NULL, &cb))
			{
                            if (cb > 0 && NOT_DIRECTLY_CONNECTED != cb)
                            {
                                pconnect_provider_confirm->pb_cred = (PBYTE) CoTaskMemAlloc(cb);
                                if (NULL != pconnect_provider_confirm->pb_cred)
                                {
                                    if (GetSecurityInfo(connection_handle, pconnect_provider_confirm->pb_cred, &cb))
                                    {
                                        pconnect_provider_confirm->cb_cred = cb;
                                    }
                                    else
                                    {
                                        CoTaskMemFree(pconnect_provider_confirm->pb_cred);
                                        pconnect_provider_confirm->pb_cred = NULL;
                                    }
                                }
                                else
                                {
                                    ERROR_OUT(("Controller::ConnectionConnectProviderConfirm: Memory Allocation Error"));
                                }    
                            }
			}
			
			/*
			 *	Post the message to the controller window (GCC and MCS
			 *	use the same window to post messages to their controllers).
			 */
			if (! PostMessage (g_pControlSap->GetHwnd(), 
							MCTRLMSG_BASE + MCS_CONNECT_PROVIDER_CONFIRM,
							(WPARAM) memory, (LPARAM) pconnect_provider_confirm))
            {
                delete pconnect_provider_confirm;
                pconnect_provider_confirm = NULL;
				ERROR_OUT(("Controller::ConnectionDeleteConnection: "
							"failed to post msg to MCS controller window. Error: %d", GetLastError()));
			}

			/*
			 *	If the result of this confirm is not successful, and the connection
			 *	is not already queued for deletion, then we need to queue it for
			 *	deletion.
			 */
			if ((result != RESULT_SUCCESSFUL) &&
				(! m_ConnectionDeletionList2.Find(connection_handle)))
			{
				/*
				 *	Put the connection object into the deletion list and set the
				 *	deletion pending flag.
				 */
				TRACE_OUT (("Controller::ConnectionConnectProviderConfirm: "
							"adding connection to deletion list"));
				m_ConnectionDeletionList2.Insert(connection_handle, connection);
				Connection_Deletion_Pending = TRUE;
				SetEvent(Connection_Deletion_Pending_Event);
			}
		}
		else
			ERROR_OUT(("Controller::ConnectionConnectProviderConfirm: "
						"failed to allocate node controller msg."));
	}
	else
	{
		/*
		 *	If the connection handle cannot be found in the connection
		 *	dictionary, then simply ignore the request.
		 */
		WARNING_OUT (("Controller::ConnectionConnectProviderConfirm: "
				"unknown connection"));
	}
}


/*
 *	Void	TransportDisconnectIndication ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates within a transport interface object when it
 *		gets a disconnect indication from the transport layer for a transport
 *		connection that is not assigned to a connection object.  This could
 *		happen in the case where a remote node issues a connect provider request
 *		followed by a disconnect provider request before this node issues a
 *		connect provider response.
 *
 *		The controller responds by simply removing the information from the
 *		connection pending list.
 *
 *	Formal Parameters:
 *		transport_connection (i)
 *			This is the transport connection handle that has been assigned to
 *			the newly created transport connection.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
Void	Controller::TransportDisconnectIndication (
					TransportConnection		transport_connection)
{

	PConnectionPending		connection_pending;
	ConnectionHandle        connection_handle;

	/*
	 *	Find the entry in the connection pending list which is associated with
	 *	the given transport connection.  If found, remove the entry.
	 */
	m_ConnPendingList2.Reset();
	while (NULL != (connection_pending = m_ConnPendingList2.Iterate(&connection_handle)))
	{
		if (IS_SAME_TRANSPORT_CONNECTION(connection_pending->transport_connection, transport_connection))
		{
			m_ConnPendingList2.Remove(connection_handle);
			delete connection_pending;
			break;
		}
	}
}

/*
 *	Void	TransportDataIndication ()
 *
 *	Private
 *
 *	Functional Description:
 *		This function is called when data is received from the transport layer
 *		on a transport connection that no other object has registered
 *		ownership of.
 *
 *	Formal Parameters:
 *		transport_connection (i)
 *			This is the transport connection handle that has been assigned to
 *			the newly created transport connection.
 *		user_data
 *			A pointer to the data received.
 *		user_data_length
 *			The length of the data received.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
Void	Controller::TransportDataIndication (
					TransportConnection		transport_connection,
					PUChar					user_data,
					ULong					user_data_length)
{
	PPacket			packet;
	PacketError		packet_error;
	PVoid			pdu_structure;

	ASSERT (g_Transport);
	/*
	 *	Create a packet from the encoded data received from the transport
	 *	interface.  Retrieve the decoded PDU structure from the packet and
	 *	pass it on to the appropriate processing routine.
	 */  
	DBG_SAVE_FILE_LINE
	packet = new Packet (
			(PPacketCoder) g_MCSCoder,
			BASIC_ENCODING_RULES,
			user_data + PROTOCOL_OVERHEAD_X224,
			user_data_length - PROTOCOL_OVERHEAD_X224,
			CONNECT_MCS_PDU,
			TRUE,
			&packet_error);

	if (packet != NULL)
	{
		if (packet_error == PACKET_NO_ERROR)
		{
			/*
			 *	Get a pointer to the decoded data.
			 */
			pdu_structure = packet->GetDecodedData ();
			
			switch (((ConnectMCSPDU *) pdu_structure)->choice)
			{
				case CONNECT_INITIAL_CHOSEN:
					ProcessConnectInitial (	
							transport_connection,
							&((ConnectMCSPDU *) pdu_structure)->u.
							connect_initial);
					break;

				case CONNECT_ADDITIONAL_CHOSEN:
					ProcessConnectAdditional (	
							transport_connection,
							&((ConnectMCSPDU *) pdu_structure)->u.
							connect_additional);
					break;

				default:
					ERROR_OUT (("Controller::TransportDataIndication: "
							"received invalid PDU (%d)",
							((ConnectMCSPDU *) pdu_structure)->choice));
					g_Transport->DisconnectRequest (transport_connection);
					break;
			}
		}
		else
		{
			/*
			 *	A memory allocation failure has prevented us from processing
			 *	this PDU.  Destroy the connection that carried it.
			 */
			WARNING_OUT (("Controller::TransportDataIndication: "
					"packet constructor failed"));
			g_Transport->DisconnectRequest (transport_connection);
		}
		packet->Unlock ();
	}
	else
	{
		/*
		 *	A memory allocation failure has prevented us from processing
		 *	this PDU.  Destroy the connection that carried it.
		 */
		WARNING_OUT (("Controller::TransportDataIndication: "
				"packet allocation failed"));
		g_Transport->DisconnectRequest (transport_connection);
	}
}

#ifdef TSTATUS_INDICATION
/*
 *	Void	TransportStatusIndication ()
 *
 *	Private
 *
 *	Functional Description:
 *		This request originates within a transport interface object when it
 *		receives a status indication from its transport layer.   This function
 *		will forward the status indication to the node controller.
 *
 *	Formal Parameters:
 *		transport_status
 *			This is a pointer to the TransportStatus structure that describes
 *			the reason for the indication.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
Void	Controller::TransportStatusIndication (
				PTransportStatus		transport_status)
{
	ULong						device_identifier_length;
	ULong						remote_address_length;
	ULong						message_length;
	PMemory						memory;
	PUChar						string_address;
	PNodeControllerMessage		node_controller_message;

	/*
	 *	Determine the length of each of the ASCII strings contained in the
	 *	transport status indications.  This will be used to allocate a
	 *	memory block large enough to hold them all.  Note that each length
	 *	includes one extra byte to hold the ASCII NULL terminator.
	 */
	device_identifier_length =
			(ULong) lstrlen (transport_status->device_identifier) + 1;
	remote_address_length =
			(ULong) lstrlen (transport_status->remote_address) + 1;
	message_length =
			(ULong) lstrlen (transport_status->message) + 1;

	/*
	 *	Use the memory manager to allocate a memory block large enough to
	 *	hold all of the strings.
	 */
	DBG_SAVE_FILE_LINE
	memory = AllocateMemory (NULL,
			(device_identifier_length + remote_address_length + message_length));

	if (memory != NULL)
	{
		DBG_SAVE_FILE_LINE
		node_controller_message = new NodeControllerMessage;

		if (node_controller_message != NULL) {
			/*
			 *	Get the address of the memory block that was allocated.
			 */
			string_address = memory->GetPointer ();

			/*
			 *	Indicate what type of message this is.
			 */
			node_controller_message->message_type = MCS_TRANSPORT_STATUS_INDICATION;

			/*
			 *	Copy all of the ASCII strings into the memory block that was
			 *	allocated above.  This block will remain valid until this
			 *	message is sent to the node controller.
			 */
			memcpy (string_address, transport_status->device_identifier,
						device_identifier_length);
			node_controller_message->u.transport_status_indication.
						device_identifier = (PChar) string_address;
			string_address += (Int) device_identifier_length;

			memcpy (string_address, transport_status->remote_address,
						remote_address_length);
			node_controller_message->u.transport_status_indication.
						remote_address = (PChar) string_address;
			string_address += (Int) remote_address_length;

			memcpy (string_address, transport_status->message,
						message_length);
			node_controller_message->u.transport_status_indication.
						message = (PChar) string_address;

			node_controller_message->u.transport_status_indication.
						state = transport_status->state;

			node_controller_message->memory = memory;

			/*
			 *	Put this message into the control queue to be sent to the node
			 *	controller during the next heartbeat.
			 */
			AddToMessageQueue (node_controller_message);
		}
		else
			WARNING_OUT(("Controller::TransportStatusIndication: "
				"WARNING - memory allocation failure"));
	}
	else
	{
		/*
		 *	A memory allocation failure has occurred.  This prevents us from
		 *	being able to deliver this status indication to the node controller.
		 *	This does not compromise the integrity of MCS, but could cause
		 *	problems at a higher level.
		 */
		ERROR_OUT (("Controller::TransportStatusIndication: "
				"WARNING - memory allocation failure"));
	}
}
#endif

/*
 *	Void	ProcessConnectInitial()
 *
 *	Private
 *
 *	Functional Description:
 *		Processes incoming connect initial PDUs.  Sends a connect provider
 *		indication to the node controller if everything checks out.
 *
 *	Formal Parameters:
 *		transport_connection (i)
 *			This is assigned transport connection handle for the connection
 *			that carried the PDU.
 *		pdu_structure (i)
 *			This is a pointer to the PDU itself.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
void	Controller::ProcessConnectInitial (
				TransportConnection		transport_connection,
				ConnectInitialPDU *		pdu_structure)
{
	PConnectionPending			connection_pending;
	PMemory						memory;
	PUChar						memory_address;
	ConnectProviderIndication	*pconnect_provider_indication;
	ConnectionHandle			connection_handle;
	BOOL    					upward_connection;
	//DomainParameters			domain_parameters;
	
	/*
	 *	Try to allocate a connection pending structure.  This will be used to
	 *	hold information about the incoming connection that will not be passed
	 *	back in the connect provider response.
	 */
	DBG_SAVE_FILE_LINE
	connection_pending = new ConnectionPending;
	DBG_SAVE_FILE_LINE
	pconnect_provider_indication = new ConnectProviderIndication;

	if (connection_pending != NULL && pconnect_provider_indication != NULL)
	{
		/*
		 *	Allocate a memory block to hold the user data field in the
		 *	incoming connection.
		 */
		DBG_SAVE_FILE_LINE
		memory = AllocateMemory (NULL, pdu_structure->user_data.length);

		if (memory != NULL) {
		
			memory_address = memory->GetPointer ();

			/*
			 *	Allocate a connection handle for this inbound connection,
			 *	and put it into the indication structure.  Also fill in the
			 *	physical connection handle, which is obtained by asking the
			 *	transport interface for it.
			 */
			connection_handle = AllocateConnectionHandle ();
			pconnect_provider_indication->connection_handle = connection_handle;
			pconnect_provider_indication->fSecure =
				g_Transport->GetSecurity ( transport_connection );

			/* 
			 *	Copy the user data field into the
			 *	newly allocated memory block.  Also set the pointers in
			 *	the node controller message structure to point into the
			 *	memory block.
			 */
			memcpy (memory_address,
					pdu_structure->user_data.value,
					pdu_structure->user_data.length);
			pconnect_provider_indication->user_data = memory_address;
			pconnect_provider_indication->user_data_length = 
										pdu_structure->user_data.length;

			/*
			 *	Retrieve the direction of the incoming connection.  Put it
			 *	into both the connect provider indication structure and the
			 *	connection pending structure.  Note that in the connection
			 *	pending structure, we need to reverse the direction of the
			 *	flag so that it is from the point-of-view of this provider.
			 */
			upward_connection = pdu_structure->upward_flag;
			pconnect_provider_indication->upward_connection = upward_connection;

			if (upward_connection)
				connection_pending->upward_connection = FALSE;
			else
				connection_pending->upward_connection = TRUE;

			/*
			 *	Retrieve the target domain parameters and put them into both
			 *	the connect provider indication structure, and into the
			 *	connection pending structure (for possible later use).
			 */
			memcpy (&(pconnect_provider_indication->domain_parameters), 
					&(pdu_structure->target_parameters), sizeof (PDUDomainParameters));
			memcpy (&(connection_pending->domain_parameters),
					&(pdu_structure->target_parameters), sizeof (PDUDomainParameters));

			/*
			 *	Retrieve the minimum domain parameters and put them into
			 *	the connection pending structure (for possible later use).
			 */
			memcpy (&(connection_pending->minimum_domain_parameters),
					&(pdu_structure->minimum_parameters), sizeof(PDUDomainParameters));

			/*
			 *	Retrieve the maximum domain parameters and put them into
			 *	the connection pending structure (for possible later use).
			 */
			memcpy (&(connection_pending->maximum_domain_parameters),
					&(pdu_structure->maximum_parameters), sizeof(PDUDomainParameters));

			/*
			 *	Post the message to the controller window (GCC and MCS
			 *	use the same window to post messages to their controllers).
			 */
			if (NULL != g_pControlSap) {
				if (! PostMessage (g_pControlSap->GetHwnd(), 
								MCTRLMSG_BASE + MCS_CONNECT_PROVIDER_INDICATION,
								(WPARAM) memory, (LPARAM) pconnect_provider_indication)) {
					ERROR_OUT(("Controller::ProcessConnectInitial: "
								"failed to post msg to MCS controller window. Error: %d", GetLastError()));
				}
			}

			/*
			 *	We also need to remember which transport interface and
			 *	transport connection are associated with this pending
			 *	MCS connection.  Then put the connection pending structure
			 *	into a list for later use.
			 */
			connection_pending->transport_connection = transport_connection;
			m_ConnPendingList2.Append(connection_handle, connection_pending);

			// No errors have occurred.
			return;
		}
	}

	/*
	 *	A memory allocation failure has occurred.  We have no choice
	 *	but to terminate the connection upon which this PDU arrived.
	 */
	ASSERT (g_Transport);
	WARNING_OUT(("Controller::ProcessConnectInitial: memory allocation failure"));
	delete connection_pending;
	delete pconnect_provider_indication;
	g_Transport->DisconnectRequest (transport_connection);
}

/*
 *	Void	ProcessConnectAdditional ()
 *
 *	Private
 *
 *	Functional Description:
 *		Processes incoming connect additional PDUs.  If the connection handle
 *		contained therein is valid, it will bind the connection to the
 *		proper connection object.
 *
 *	Formal Parameters:
 *		transport_connection (i)
 *			This is assigned transport connection handle for the connection
 *			that carried the PDU.
 *		pdu_structure (i)
 *			This is a pointer to the PDU itself.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		None.
 */
Void	Controller::ProcessConnectAdditional (
				TransportConnection		transport_connection,
				ConnectAdditionalPDU *	pdu_structure)
{
	ConnectionHandle		connection_handle;
	Priority				priority;
	PConnection				connection;

	ASSERT (g_Transport);
	
	connection_handle = (ConnectionHandle) pdu_structure->called_connect_id;
	priority = (Priority) pdu_structure->data_priority;

	if (NULL != (connection = m_ConnectionList2.Find(connection_handle)))
	{
		/*
		 *	The indicated connection does exist, so call upon it to accept
		 *	and register the new transport connection.
		 */
		connection->RegisterTransportConnection (transport_connection, priority);
	}
	else
	{
		/*
		 *	The indicated connection handle is not in the dictionary.  Issue
		 *	a connect result with a failure result, and disconnect the
		 *	transport connection.
		 */
		ConnectResult (transport_connection, RESULT_UNSPECIFIED_FAILURE);

		g_Transport->DisconnectRequest (transport_connection);
	}
}

/*
 *	Void	ConnectResponse ()
 *
 *	Private
 *
 *	Functional Description:
 *		Sends a failed connect response PDU (when something goes wrong).
 *
 *	Formal Parameters:
 *		transport_connection (i)
 *			This is assigned transport connection handle for the connection
 *			that is to carry the PDU.
 *		result (i)
 *			This is the result being sent in the connect response.
 *		domain_parameters (i)
 *			This is a pointer to a structure containing domain parameters.
 *			These parameters will not be used for anything since the connection
 *			is being rejected.
 *		connect_id (i)
 *			This is the connect ID that would be used for any additional
 *			transport connection to be bound to this one.  This is not
 *			required since the connection is being rejected.
 *		user_data (i)
 *			This is a pointer to the user data to be transmitted to the remote
 *			side along with the response.
 *		user_data_lengthn (i)
 *			This is the length of the above user data.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 */
Void	Controller::ConnectResponse (
				TransportConnection		transport_connection,
				Result					result,
				PDomainParameters		domain_parameters,
				ConnectID				connect_id,
				PUChar					user_data,
				ULong					user_data_length)
{
	ConnectMCSPDU		connect_response_pdu;
	PPacket				packet;
	PacketError			packet_error;
	//PVoid				encoded_data;
	//ULong				encoded_data_length;

	ASSERT (g_Transport);
	/*
	 * Fill in the ConnectResponse 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;

	/*
	 * 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..
	 */
	DBG_SAVE_FILE_LINE
	packet = new Packet (
			(PPacketCoder) g_MCSCoder,
			BASIC_ENCODING_RULES,
			&connect_response_pdu,
			CONNECT_MCS_PDU,
			TRUE,
			&packet_error);

	if (packet != NULL)
	{
		if (packet_error == PACKET_NO_ERROR)
		{
			/*
			 * Send the packet through the transport interface.
			 */
#ifdef DEBUG
			TransportError err = DataRequest (transport_connection, 
												(PSimplePacket) packet);
			ASSERT (err == TRANSPORT_NO_ERROR);
#else // DEBUG
			DataRequest (transport_connection, (PSimplePacket) packet);
#endif // DEBUG
		}
		else
		{
			/*
			 *	The packet creation has failed due to an internal error so 
			 *	report the error through a print statement.  Note that no
			 *	further action need be taken since this transport connection
			 *	is being terminated anyway.
			 */
			WARNING_OUT (("Controller::ConnectResponse: "
					"internal allocation failure"));
		}
		packet->Unlock ();
	}
	else
	{
		/*
		 *	The packet creation has failed so report the error through a print
		 *	statement.  Note that no further action need be taken since this
		 *	transport connection is being terminated anyway.
		 */
		WARNING_OUT (("Controller::ConnectResponse: "
				"packet allocation failure"));
	}
}

/*
 *	Void	ConnectResult ()
 *
 *	Private
 *
 *	Functional Description:
 *		Sends a failed connect response PDU (when something goes wrong).
 *
 *	Formal Parameters:
 *		transport_connection (i)
 *			This is assigned transport connection handle for the connection
 *			that is to carry the PDU.
 *		result (i)
 *			This is the result being sent in the connect result.
 *
 *	Return Value:
 *		None.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 */
Void	Controller::ConnectResult (
				TransportConnection		transport_connection,
				Result					result)
{
	ConnectMCSPDU		connect_result_pdu;
	PPacket				packet;
	PacketError			packet_error;
	//PVoid				encoded_data;
	//ULong				encoded_data_length;

	ASSERT (g_Transport);
	/*
	 * Fill in the PDU structure to be encoded.
	 */
	connect_result_pdu.choice = CONNECT_RESULT_CHOSEN;
	connect_result_pdu.u.connect_result.result = (PDUResult)result;
	
	/*
	 * 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..
	 */
	DBG_SAVE_FILE_LINE
	packet = new Packet (
			(PPacketCoder) g_MCSCoder,
			BASIC_ENCODING_RULES,
			&connect_result_pdu,
			CONNECT_MCS_PDU,
			TRUE,
			&packet_error);

	if (packet != NULL)
	{
		if (packet_error == PACKET_NO_ERROR)
		{
			/*
			 * Send the packet through the transport interface.
			 */
#ifdef DEBUG
			TransportError err = DataRequest (transport_connection, 
											  (PSimplePacket) packet);
			ASSERT (err == TRANSPORT_NO_ERROR);
#else // DEBUG
			DataRequest (transport_connection, (PSimplePacket) packet);
#endif // DEBUG
		}
		else
		{
			/*
			 *	The packet creation has failed due to an internal error so 
			 *	report the error through a print statement.  Note that no
			 *	further action need be taken since this transport connection
			 *	is being terminated anyway.
			 */
			WARNING_OUT (("Controller::ConnectResult: "
					"internal allocation failure"));
		}
		packet->Unlock ();
	}
	else
	{
		/*
		 *	The packet creation has failed so report the error through a print
		 *	statement.  Note that no further action need be taken since this
		 *	transport connection is being terminated anyway.
		 */
		WARNING_OUT (("Controller::ConnectResult: "
				"packet allocation failure"));
	}
}

/*
 *	ConnectionHandle	AllocateConnectionHandle ()
 *
 *	Private
 *
 *	Functional Description:
 *		This routine allocates a unique connection handle to be used for a newly
 *		created connection object.  It is based on a rolling instance variable,
 *		so that no two handles will ever be reused until the number rolls
 *		over at 0xffff.
 *
 *		Note that 0 is not a valid connection handle, and will never be used.
 *
 *	Formal Parameters:
 *		None.
 *
 *	Return Value:
 *		The unique connection handle.
 *
 *	Side Effects:
 *		None.
 *
 *	Caveats:
 *		Note that the assumption is made that there will never be more than
 *		65,534 handles in use at once.  In other words, this loop assumes that
 *		there is at least 1 available handle left.  If there is not, then the
 *		loop will hang forever (this is a pretty safe bet for now).
 */
ConnectionHandle	Controller::AllocateConnectionHandle ()
{
	/*
	 *	This loop simply increments a rolling number, looking for the next
	 *	one that is not already in use.
	 */
	while (1)
	{
		Connection_Handle_Counter++;

		/*
		 *	0 is not a valid handle, so skip it.
		 */
		if (Connection_Handle_Counter == 0)
			continue;

		/*
		 *	If this handle is not in use, break from the loop and use it.
		 */
		if (! m_ConnectionList2.Find(Connection_Handle_Counter))
			break;
	}

	return (Connection_Handle_Counter);
}

BOOL    Controller::GetLocalAddress(ConnectionHandle	connection_handle,
									TransportAddress	local_address,
									PInt				local_address_length)
{
	PConnection				connection = NULL;
	PConnectionPending		connection_pending = NULL;
	TransportError			transport_error;
	BOOL    				return_value = FALSE;
	
	if (NULL == (connection = m_ConnectionList2.Find(connection_handle)))
	{
		connection_pending = m_ConnPendingList2.Find(connection_handle);
	}

	if(connection || connection_pending)
	{	
		// Ask the local address to the transport interface
		if (connection)
		{
			transport_error = ::GetLocalAddress(connection->GetTransportConnection(TOP_PRIORITY),
											  local_address,
											  local_address_length);
		}
		else
		{
			transport_error = ::GetLocalAddress(connection_pending->transport_connection,
												local_address,
												local_address_length);
		}
		
		// Check the error code
		if (TRANSPORT_NO_ERROR == transport_error) {
			return_value = TRUE;
		}
	}
	 
	return(return_value);
}

BOOL Controller::FindSocketNumber(ConnectionHandle connection_handle, SOCKET * socket_number)
{
	PConnection	connection = NULL;
	PConnectionPending connection_pending = NULL;

	if (NULL != (connection = m_ConnectionList2.Find(connection_handle)))
	{
	    TransportConnection XprtConn = connection->GetTransportConnection(TOP_PRIORITY);
        if (IS_SOCKET(XprtConn))
        {
		    * socket_number = XprtConn.nLogicalHandle;
    		return TRUE;
    	}
	}
	else
	if (NULL != (connection_pending = m_ConnPendingList2.Find(connection_handle)))
	{
        if (IS_SOCKET(connection_pending->transport_connection))
        {
		    * socket_number = connection_pending->transport_connection.nLogicalHandle;
		    return TRUE;
		}
	}
	return FALSE;
}