able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/t120/mst120/control.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3333 lines
99 KiB
C++
Raw Blame History

#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"));
m_DomainList2.Append(*domain_selector, domain);
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)) {
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;
}
Reference in a new issue View git blame Copy permalink