473 lines
16 KiB
C++
473 lines
16 KiB
C++
#ifndef _GCC_CONTROLLER_
|
|
#define _GCC_CONTROLLER_
|
|
|
|
/*
|
|
* gcontrol.h
|
|
*
|
|
* Copyright (c) 1995 by DataBeam Corporation, Lexington, KY
|
|
*
|
|
* Abstract:
|
|
* It is the responsibility of the controller to create and destroy many
|
|
* of the other objects in the system at run-time. There is should only
|
|
* be one controller in existence at a time per GCC provider. The
|
|
* controller is constructed during system initialization, and not
|
|
* destroyed until the provider is shut down. The controller's primary
|
|
* responsibility is to maintain five "layers" of objects in the system at
|
|
* run-time. These include the Application Interface, the SAPs (the
|
|
* Control SAP as well as the Application SAPs), the Conference objects,
|
|
* the MCSUser object (which is actualy created by the conference object),
|
|
* and the MCS Interface. It also "plugs" together objects in adjacent
|
|
* layers by informing a newly created object of the identity of those
|
|
* objects with which it must communicate. The newly created object can
|
|
* then register itself with the appropriate objects in the layers above
|
|
* and below. The controller plays a small role in the passing of
|
|
* information during a conference (this is handled by the objects it
|
|
* creates).
|
|
*
|
|
* It is worth noting that the controller is the primary recipient of
|
|
* owner callbacks in the GCC system. Most of the objects in its "object
|
|
* stack" are capable of issuing owner callbacks to the controller for
|
|
* various events and requests.
|
|
*
|
|
* The controller is not completely portable. Since the nature of
|
|
* application and MCS interfaces will vary from platform to platform, the
|
|
* interface objects that must be created will also vary. It is necessary
|
|
* for the controller to know which objects to create and destroy during
|
|
* initialization and cleanup. Other than this, however, the rest of the
|
|
* code in the controller class should port cleanly.
|
|
*
|
|
* The constructor performs all activity required to prepare GCC for use.
|
|
* It creates an instance of the Memory Manager class (and possibly a
|
|
* Message Memory Manager class in certain environments), which will be
|
|
* used for memory handling by other objects in the system. It creates the
|
|
* GccAppInterface objects that will be used to communicate with all user
|
|
* applications (including the node controller). It creates the MCS
|
|
* Interface object that will be used to communicate with MCS. GCC relies
|
|
* on an owner callback from a GccAppInterface object to give it a
|
|
* heartbeat. It is during this heartbeat that the controller does all of
|
|
* its work at run-time.
|
|
*
|
|
* The destructor essentially does the opposite of what the constructor
|
|
* does (as you might expect). It destroys all objects that are "owned"
|
|
* by the controller, cleanly shutting everything down.
|
|
*
|
|
* As mentioned above, the controller is the primary recipient of owner
|
|
* callbacks in the GCC system. To accomplish this it overrides the
|
|
* Owner-Callback member function. It can then pass its "this" pointer to
|
|
* objects that it creates, allowing them to issue owner callbacks when
|
|
* necessary. Everything the controller does at run-time is in response
|
|
* to these owner callbacks.
|
|
*
|
|
* The controller is the prime recipient of connect provider indications
|
|
* from MCS. Many of the messages that are passed between GCC and the
|
|
* GccAppInterface before a conference is established involve the
|
|
* controller. These include ConferenceCreateIndication,
|
|
* ConferenceInviteIndication, etc. Also, the controller object is
|
|
* exclusively responsible for handling conference queries since it
|
|
* maintains a complete list of all the conferences that exist in the
|
|
* system.
|
|
*
|
|
* Portable:
|
|
* Not Completely (80 % portable)
|
|
* Member functions which aren't portable:
|
|
* - GCCControl()
|
|
* - ~GCCControl()
|
|
* - EventLoop()
|
|
* - PollCommDevices()
|
|
* - CreateApplicationSap()
|
|
*
|
|
* Protected Instance Variables:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*
|
|
* Author:
|
|
* blp
|
|
*/
|
|
|
|
#include "sap.h"
|
|
#include "csap.h"
|
|
#include "appsap.h"
|
|
#include "conf.h"
|
|
#include "pktcoder.h"
|
|
#include "privlist.h"
|
|
#include "mcsdllif.h"
|
|
#include "t120app.h"
|
|
|
|
// #include "gccncif.h"
|
|
|
|
extern CRITICAL_SECTION g_csGCCProvider;
|
|
|
|
|
|
/*
|
|
** These are the message bases used by the controller object. Any
|
|
** owner callback message received from an object that the controller
|
|
** created must have a message base added to it before it is received
|
|
** at the controller.
|
|
*/
|
|
#define MCS_INTERFACE_MESSAGE_BASE 300 // Leave room for status
|
|
|
|
enum
|
|
{
|
|
GCTRL_REBUILD_CONF_POLL_LIST = GCTRLMSG_BASE + 1,
|
|
};
|
|
|
|
|
|
// permit to enroll callback list
|
|
class CApplet;
|
|
class CAppletList : public CList
|
|
{
|
|
DEFINE_CLIST(CAppletList, CApplet*)
|
|
};
|
|
|
|
/*
|
|
** The conference information structure is used to temporarily store
|
|
** information needed to create a conference while waiting for a
|
|
** conference create response.
|
|
*/
|
|
typedef struct PENDING_CREATE_CONF
|
|
{
|
|
// a destructor to this data structure
|
|
PENDING_CREATE_CONF(void);
|
|
~PENDING_CREATE_CONF(void);
|
|
|
|
LPSTR pszConfNumericName;
|
|
LPWSTR pwszConfTextName;
|
|
BOOL password_in_the_clear;
|
|
BOOL conference_is_locked;
|
|
BOOL conference_is_listed;
|
|
BOOL conference_is_conductible;
|
|
GCCTerminationMethod termination_method;
|
|
PPrivilegeListData conduct_privilege_list;
|
|
PPrivilegeListData conduct_mode_privilege_list;
|
|
PPrivilegeListData non_conduct_privilege_list;
|
|
LPWSTR pwszConfDescription;
|
|
ConnectionHandle connection_handle;
|
|
UserID parent_node_id;
|
|
UserID top_node_id;
|
|
TagNumber tag_number;
|
|
}
|
|
PENDING_CREATE_CONF;
|
|
|
|
/*
|
|
** This defines the template for the list that keeps track of information
|
|
** associated with a conference that is waiting for a response on a
|
|
** create conference indication.
|
|
*/
|
|
class CPendingCreateConfList2 : public CList2
|
|
{
|
|
DEFINE_CLIST2(CPendingCreateConfList2, PENDING_CREATE_CONF*, GCCConfID)
|
|
};
|
|
|
|
|
|
/*
|
|
** The join information structure is used to temporarily store
|
|
** information needed to join a conference after the join response is
|
|
** issued.
|
|
*/
|
|
typedef struct PENDING_JOIN_CONF
|
|
{
|
|
PENDING_JOIN_CONF(void);
|
|
~PENDING_JOIN_CONF(void);
|
|
|
|
CPassword *convener_password;
|
|
CPassword *password_challenge;
|
|
LPWSTR pwszCallerID;
|
|
BOOL numeric_name_present;
|
|
GCCConfID nConfID;
|
|
}
|
|
PENDING_JOIN_CONF;
|
|
|
|
/*
|
|
** This defines the template for the list that keeps track of information
|
|
** associated with an outstanding join request.
|
|
*/
|
|
class CPendingJoinConfList2 : public CList2
|
|
{
|
|
DEFINE_CLIST2_(CPendingJoinConfList2, PENDING_JOIN_CONF*, ConnectionHandle)
|
|
};
|
|
|
|
|
|
// Holds the list of outstanding query request
|
|
class CPendingQueryConfList2 : public CList2
|
|
{
|
|
DEFINE_CLIST2_(CPendingQueryConfList2, GCCConfID, ConnectionHandle)
|
|
};
|
|
|
|
|
|
extern HANDLE g_hevGCCOutgoingPDU;
|
|
|
|
|
|
class GCCController : public CRefCount
|
|
{
|
|
public:
|
|
|
|
GCCController(PGCCError);
|
|
~GCCController(void);
|
|
|
|
void RegisterAppSap(CAppSap *);
|
|
void UnRegisterAppSap(CAppSap *);
|
|
|
|
void RegisterApplet(CApplet *);
|
|
void UnregisterApplet(CApplet *);
|
|
|
|
CConf *GetConfObject(GCCConfID nConfID) { return m_ConfList2.Find(nConfID); }
|
|
|
|
// Functions initiated from the node controller
|
|
GCCError ConfCreateRequest(CONF_CREATE_REQUEST *, GCCConfID *);
|
|
|
|
void WndMsgHandler ( UINT uMsg );
|
|
BOOL FlushOutgoingPDU ( void );
|
|
void SetEventToFlushOutgoingPDU ( void ) { ::SetEvent(g_hevGCCOutgoingPDU); }
|
|
|
|
// Functions initiated from Control SAP
|
|
GCCError ConfCreateResponse(PConfCreateResponseInfo);
|
|
GCCError ConfQueryRequest(PConfQueryRequestInfo);
|
|
GCCError ConfQueryResponse(PConfQueryResponseInfo);
|
|
GCCError ConfJoinRequest(PConfJoinRequestInfo, GCCConfID *);
|
|
GCCError ConfJoinIndResponse(PConfJoinResponseInfo);
|
|
GCCError ConfInviteResponse(PConfInviteResponseInfo);
|
|
GCCError FailConfJoinIndResponse(GCCConfID, ConnectionHandle);
|
|
GCCError FailConfJoinIndResponse(PConfJoinResponseInfo);
|
|
void RemoveConfJoinInfo(ConnectionHandle hConn);
|
|
|
|
// Functions initiated from Conference object
|
|
GCCError ProcessConfEstablished(GCCConfID);
|
|
GCCError ProcessConfTerminated(GCCConfID, GCCReason);
|
|
|
|
// Functions initiated from the MCS Interface
|
|
GCCError ProcessConnectProviderIndication(PConnectProviderIndication);
|
|
GCCError ProcessConferenceCreateRequest(PConferenceCreateRequest, PConnectProviderIndication);
|
|
GCCError ProcessConferenceQueryRequest(PConferenceQueryRequest, PConnectProviderIndication);
|
|
GCCError ProcessConferenceJoinRequest(PConferenceJoinRequest, PConnectProviderIndication);
|
|
GCCError ProcessConferenceInviteRequest(PConferenceInviteRequest, PConnectProviderIndication);
|
|
GCCError ProcessConnectProviderConfirm(PConnectProviderConfirm);
|
|
GCCError ProcessConferenceQueryResponse(PConferenceQueryResponse, PConnectProviderConfirm);
|
|
GCCError ProcessDisconnectProviderIndication(ConnectionHandle);
|
|
void CancelConfQueryRequest(ConnectionHandle);
|
|
|
|
private:
|
|
|
|
/*
|
|
** Routines called from the Owner-Callback function
|
|
*/
|
|
|
|
// Miscelaneous support functions
|
|
GCCConfID AllocateConferenceID();
|
|
GCCConfID AllocateQueryID();
|
|
|
|
GCCConfID GetConferenceIDFromName(
|
|
PGCCConferenceName conference_name,
|
|
GCCNumericString conference_modifier);
|
|
|
|
void RebuildConfPollList ( void );
|
|
void PostMsgToRebuildConfPollList ( void );
|
|
|
|
private:
|
|
|
|
CPendingCreateConfList2 m_PendingCreateConfList2;
|
|
CPendingJoinConfList2 m_PendingJoinConfList2;
|
|
CPendingQueryConfList2 m_PendingQueryConfList2;
|
|
|
|
CConfList m_ConfDeleteList;
|
|
CConfList2 m_ConfList2;
|
|
|
|
CAppSapList m_AppSapList;
|
|
|
|
BOOL m_fConfListChangePending;
|
|
|
|
GCCConfID m_ConfIDCounter;
|
|
GCCConfID m_QueryIDCounter;
|
|
|
|
BOOL m_fControllerIsExiting;
|
|
|
|
DWORD m_dwControllerWaitTimeout;
|
|
DWORD m_dwControllerEventMask;
|
|
|
|
// These list are used only for iterating. Whenever a conference or
|
|
// application SAP object is deleted (or created in the case of an
|
|
// application SAP) it is added to the dictionary list first and
|
|
// a flag is set which forces the Polled list to get recreated at the
|
|
// top of the next heartbeat.
|
|
CConfList m_ConfPollList;
|
|
|
|
// T120 Applet list
|
|
CAppletList m_AppletList;
|
|
|
|
};
|
|
|
|
extern GCCController *g_pGCCController;
|
|
|
|
/*
|
|
* GCCController (PGCCError gcc_error)
|
|
*
|
|
* Public member function of Conference
|
|
*
|
|
* Function Description
|
|
* This is the Windows 32 Bit version of the GCC controller constructor. It
|
|
* is responsible for initializing all the instance variables used by this
|
|
* class. It is also responsible for creating the memory manager, the
|
|
* packet coder, the Node Controller application interface, the Shared
|
|
* memory interface used to communicate with enrolled applications, the
|
|
* Node Controller SAP and the MCS Interface. It also sets up the
|
|
* g_csGCCProvider that protects the core of GCC in the multi-threaded
|
|
* Win32 environment. It also sets up a number of Windows Event objects
|
|
* used to signal the GCC thread when various events happen at the
|
|
* interfaces. The last thing it does before returning if no errors have
|
|
* occured is launch the GCC thread. Fatal errors are returned from this
|
|
* constructor in the return value.
|
|
*
|
|
* Formal Parameters:
|
|
* gcc_error - (o) Errors that occur are returned here.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* This constructor launches the GCC thread if no errors occur.
|
|
*
|
|
* Caveats
|
|
* This constructor is very specific to the Win32 environment. When
|
|
* porting GCC to other platforms, this constructor will have to be
|
|
* rewritten for the proper platform.
|
|
*/
|
|
|
|
/*
|
|
* GCCController( USHORT timer_duration,
|
|
* PGCCError gcc_error)
|
|
*
|
|
* Public member function of Conference
|
|
*
|
|
* Function Description
|
|
* This is the Windows 16 Bit version of the GCC controller constructor. It
|
|
* is responsible for initializing all the instance variables used by this
|
|
* class. It is also responsible for creating the memory manager, the
|
|
* packet coder, the Node Controller application interface, the Shared
|
|
* memory interface used to communicate with enrolled applications, the
|
|
* Node Controller SAP and the MCS Interface. It also sets up the
|
|
* internal Windows timer if a timer_interval other than zero is specified.
|
|
* Fatal errors are returned from this constructor in the return value.
|
|
*
|
|
* Formal Parameters:
|
|
* timer_duration - (i) Timer interval in miliseconds that the
|
|
* heartbeat will trigger at.
|
|
* instance_handle - (i) This is the windows instance handle used to
|
|
* set up the Windows timer.
|
|
* gcc_error - (o) Errors that occur are returned here.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None.
|
|
*
|
|
* Caveats
|
|
* This constructor is very specific to the Win16 environment. When
|
|
* porting GCC to other platforms, this constructor will have to be
|
|
* rewritten for the proper platform.
|
|
*/
|
|
|
|
/*
|
|
* ~GCCController();
|
|
*
|
|
* Public member function of Conference
|
|
*
|
|
* Function Description
|
|
* This is the Controller destructor. All platform specific cleanup that
|
|
* occurs is included in this destructor but is "macro'd" out in
|
|
* environments where the cleanup is not necessary (things like
|
|
* critical sections, and Windows timers). Deleting the controller
|
|
* essentially shuts down GCC. Deleting all the active conferences, SAPs,
|
|
* and interfaces along with all the GCC support modules (memory manager,
|
|
* packet coder, etc.).
|
|
*
|
|
* Formal Parameters:
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None.
|
|
*
|
|
* Caveats
|
|
* This destructor includes platform specific code. It may be necessary
|
|
* to include some platform specific code here when porting GCC to
|
|
* other platforms. Macros should be used to isolate this code
|
|
* where ever possible.
|
|
*/
|
|
|
|
/*
|
|
* ULONG Owner-Callback ( UINT message,
|
|
* LPVOID parameter1,
|
|
* ULONG parameter2);
|
|
*
|
|
* Public member function of Conference
|
|
*
|
|
* Function Description
|
|
* This function overides the base class function and is used to
|
|
* receive all owner callback information from the objects the
|
|
* the controller creates.
|
|
*
|
|
* Formal Parameters:
|
|
* message - (i) Message number including base offset.
|
|
* parameter1 - (i) void pointer of message data.
|
|
* parameter2 - (i) Long holding message data.
|
|
*
|
|
* Return Value
|
|
* GCC_NO_ERROR - No error occured.
|
|
* GCC_ALLOCATION_FAILURE - Resource error occured.
|
|
* GCC_INVALID_CONFERENCE_NAME - Invalid conference name passed in.
|
|
* GCC_FAILURE_CREATING_DOMAIN - Failure creating domain.
|
|
* GCC_BAD_NETWORK_ADDRESS - Bad network address passed in.
|
|
* GCC_BAD_NETWORK_ADDRESS_TYPE - Bad network address type passed in.
|
|
* GCC_CONFERENCE_ALREADY_EXISTS - Conference specified already exists.
|
|
* GCC_INVALID_TRANSPORT - Cannot find specified transport.
|
|
* GCC_INVALID_ADDRESS_PREFIX - Bad transport address passed in.
|
|
* GCC_INVALID_TRANSPORT_ADDRESS - Bad transport address
|
|
* GCC_BAD_SESSION_KEY - Enrolling with invalid session key.
|
|
* GCC_INVALID_PASSWORD - Invalid password passed in.
|
|
* GCC_BAD_USER_DATA - Invalid user data passed in.
|
|
* GCC_INVALID_JOIN_RESPONSE_TAG - No match found for join response tag
|
|
* GCC_NO_SUCH_APPLICATION - Invalid SAP handle passed in.
|
|
* GCC_CONFERENCE_NOT_ESTABLISHED - Request failed because conference
|
|
* was not established.
|
|
* GCC_BAD_CAPABILITY_ID - Invalid capability ID passed in.
|
|
* GCC_NO_SUCH_APPLICATION - Bad SAP handle passed in.
|
|
* GCC_DOMAIN_PARAMETERS_UNACCEPTABLE - Domain parameters were
|
|
* unacceptable for this connection.
|
|
*
|
|
* Side Effects
|
|
* None.
|
|
*
|
|
* Caveats
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* void EventLoop();
|
|
*
|
|
* Public member function of Conference
|
|
*
|
|
* Function Description
|
|
* This routine is only used for the 32 bit windows platform. It gets
|
|
* called whenever an event occurs in this environment. These include
|
|
* timer events as well as PDU and message events
|
|
*
|
|
* Formal Parameters:
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None.
|
|
*
|
|
* Caveats
|
|
* None.
|
|
*/
|
|
|
|
#endif // _GCC_CONTROLLER_
|
|
|