1075 lines
36 KiB
C++
1075 lines
36 KiB
C++
#include "precomp.h"
|
||
|
||
/* tprtintf.cpp
|
||
*
|
||
* Copyright (c) 1996 by Microsoft Corporation
|
||
*
|
||
* Abstract:
|
||
* This is the implementation file for the Win32 PSTN transport stack.
|
||
* This file contains all of the public functions needed to use
|
||
* the PSTN stack. Transprt.cpp really performs three functions:
|
||
*
|
||
* 1. Since this is a Win32 DLL, it provides a C to C++ conversion
|
||
* layer. The functions called by the user are not processed
|
||
* in this file, they are passed on down to the C++ object that
|
||
* handles it (g_pController). If we supplied a C++
|
||
* interface to the user, it would force the user to use C++ and
|
||
* it would force them to use a C++ compiler that used the same
|
||
* name-mangling algorithm as our compiler(s).
|
||
*
|
||
* 2. It holds the code that acts as the administrator for the PSTN
|
||
* thread. This is a fairly straightforward piece of code that
|
||
* is explained later in this comment block.
|
||
*
|
||
* 3. This file provides thread synchronization to the underlying
|
||
* code by protecting it with a CRITICAL_SECTION. This prevents
|
||
* multiple threads from executing the code at the same time.
|
||
*
|
||
*
|
||
*
|
||
* CREATING A SECONDARY "PSTN" THREAD
|
||
*
|
||
* Since this is a Win32 DLL, we create a seperate thread to maintain the
|
||
* PSTN DLL. During initialization of the DLL, we create the secondary or
|
||
* PSTN thread which runs in response to timeouts and system events. It
|
||
* uses the WaitForMultipleObjects() system call to wait for events that
|
||
* need to be processed.
|
||
*
|
||
* This DLL is event driven. When a new com port is opened and
|
||
* initialized, it uses Win32 event objects to signal significant events.
|
||
* Three events that can occur are read events, write events, and control
|
||
* events. An example of a control event is a change in the carrier
|
||
* detect signal.
|
||
*
|
||
* When the ComPort object initializes an event object, it registers the
|
||
* object with the PSTN thread, by placing it in the PSTN Event_List. It
|
||
* not only registers the event, but also all of the data needed to
|
||
* identify the event. The following structure must be filled out by the
|
||
* ComPort for each event that it registers.
|
||
* struct
|
||
* {
|
||
* HANDLE event; // event object
|
||
* WIN32Event event_type; // READ, WRITE, CONTROL
|
||
* BOOL delete_event; // FLAG, delete it?
|
||
* PhysicalHandle physical_handle; // Handle associated with
|
||
* // ComPort
|
||
* IObject * physical_layer; // this pointer of comport
|
||
* } EventObject;
|
||
*
|
||
* When an event occurs, the PSTN thread makes a call directly to the
|
||
* ComPort object to notify it. If the event that occured was a WRITE
|
||
* event, we also issue a PollTransmitter() function call to the
|
||
* g_pController object so that it can transmit more data.
|
||
*
|
||
* If a READ event occurs, we call the ComPort object directly to notify
|
||
* it that the event occurred. We then issue a PollReceiver() function
|
||
* call to the g_pController object so that we can process the
|
||
* received data. We then issue a PollTransmitter() to the
|
||
* g_pController object. Logically, this doesn't make much sense,
|
||
* but if you study the Q922 code, you'll see that we sometimes don't
|
||
* transmit data until we receive notification that previously transmitted
|
||
* data was successfully transmitted.
|
||
*
|
||
* If a CONTROL event occurs, we call the ComPort object directly to
|
||
* notify it that the event occurred. We then issue a PollReceiver()
|
||
* function call to the g_pController object so that the CONTROL
|
||
* event will be processed.
|
||
*
|
||
*
|
||
*
|
||
* X.214 INTERFACE
|
||
*
|
||
* You will notice that many of the entry points to this DLL were taken
|
||
* from the X.214 service definition. These entry points are consistent
|
||
* between all DataBeam Transport DLLs. This gives the user application
|
||
* a consistent interface.
|
||
*
|
||
*
|
||
* PHYSICAL API
|
||
*
|
||
* Some of the entry points to this DLL are specific to the creation
|
||
* and use of LOGICAL connections, and some of the entry points are
|
||
* specific to the creation and deletion of PHYSICAL connections. The
|
||
* out-of-band physical API is new as of version 2.0 and provides the
|
||
* user with an optional way of making PHYSICAL connections. In earlier
|
||
* versions of the Transport stacks, there was no Physical API and PHYSICAL
|
||
* connections were made in-band using the TConnectRequest() and
|
||
* TDisconnectRequest() calls. This form of call control is still
|
||
* supported in this version.
|
||
*
|
||
* Although the user can use out-of-band (PHYSICAL call control) and
|
||
* in-band call control, the DLL must be put in one mode or the other.
|
||
* The DLL can NOT function in both modes simultaneously. The user
|
||
* determines the DLL's mode of operation by the calls it makes to it.
|
||
* If the user makes the TPhysicalInitialize() function call to the DLL
|
||
* before it issues the TInitialize() function call, the DLL is in the
|
||
* out-of-band call control mode. If the user only makes the TInitialize()
|
||
* function call, by default the DLL will be in the in-band call control
|
||
* mode.
|
||
*
|
||
* If MCS will be using this DLL, it makes the TInitialize() function call.
|
||
* Therefore, if the user wants to use the out-of-band call control mode,
|
||
* it should call TPhysicalInitialize() before it initializes MCS.
|
||
*
|
||
*
|
||
* Static Variables:
|
||
* Static_Instance_Handle - Instance handle passed to the DLL when it
|
||
* is started. The instance handle is used
|
||
* for Win32 system calls.
|
||
* g_pController - This is a pointer to the controller that
|
||
* maintains the T123 stacks.
|
||
* m_cUsers - This is incremented each time someone
|
||
* calls the TInitialize function. It is
|
||
* decremented each time someone calls the
|
||
* TCleanup function. When this value
|
||
* reaches 0, we destroy the transport
|
||
* controller.
|
||
* g_hWorkerThread - This global variable keeps the handle of
|
||
* the thread we spawn on initialization.
|
||
* g_dwWorkerThreadID - Thread identifier
|
||
* g_hWorkerThreadEvent - This is an event object that is used to
|
||
* synchronize actions between the 2 threads.
|
||
* g_hThreadTerminateEvent - This event is used to signal the PSTN
|
||
* thread that it needs to terminate.
|
||
* ComPort_List - This is a list of the ComPort objects
|
||
* serviced by this DLL.
|
||
* class.
|
||
* Number_Of_Diagnostic_Users - This variable keeps up with the number of
|
||
* people using who called T120DiagnosticCreate.
|
||
* We won't delete the Diagnostic class until
|
||
* an equal number of people call
|
||
* T120DiagnosticDestroy.
|
||
*
|
||
*/
|
||
|
||
/*
|
||
** External Interfaces
|
||
*/
|
||
|
||
#include "tprtintf.h"
|
||
#include "comport.h"
|
||
|
||
#define TPRTINTF_MAXIMUM_WAIT_OBJECTS (1 + 16)
|
||
|
||
/*
|
||
** Global variables used within the C to C++ converter.
|
||
*/
|
||
HINSTANCE g_hDllInst = NULL;
|
||
CTransportInterface *g_pTransportInterface = NULL;
|
||
CRITICAL_SECTION g_csPSTN;
|
||
Timer *g_pSystemTimer = NULL;
|
||
TransportController *g_pController = NULL;
|
||
HANDLE g_hWorkerThread = NULL;
|
||
DWORD g_dwWorkerThreadID = 0;
|
||
HANDLE g_hWorkerThreadEvent= NULL;
|
||
HANDLE g_hThreadTerminateEvent = NULL;
|
||
DictionaryClass *g_pComPortList2 = NULL;
|
||
SListClass *g_pPSTNEventList = NULL;
|
||
TransportCallback g_pfnT120Notify = NULL;
|
||
void *g_pUserData = NULL;
|
||
BOOL g_fEventListChanged = FALSE;
|
||
|
||
/*
|
||
** The following defines the MCATPSTN User window class name.
|
||
** This name must be unique, system wide.
|
||
*/
|
||
|
||
#define MCATPSTN_USER_WINDOW_CLASS_NAME "NMPSTN USER Message Window"
|
||
|
||
/*
|
||
/*
|
||
** Timer duration. We will poll the DLL every X milliseconds. During
|
||
** this time, we can do any maintenance that is necessary
|
||
*/
|
||
#define MCATPSTN_TIMER_DURATION 250
|
||
|
||
/*
|
||
** These are prototypes
|
||
*/
|
||
DWORD T123_WorkerThreadProc(DWORD *);
|
||
|
||
|
||
/*
|
||
* BOOL WINAPI DllMain (
|
||
* HINSTANCE instance_handle,
|
||
* DWORD reason,
|
||
* LPVOID)
|
||
*
|
||
* Functional Description:
|
||
* This routine is the DLL startup routine. It is analagous to the
|
||
* constructor of a class. It is called by Windows when the DLL is
|
||
* loaded and when other significant events occur.
|
||
*/
|
||
#ifdef _DEBUG
|
||
|
||
#define INIT_DBG_ZONE_DATA
|
||
#include "fsdiag2.h"
|
||
|
||
#endif /* _DEBUG */
|
||
|
||
|
||
BOOL WINAPI DllMain(HINSTANCE hDllInst, DWORD reason, LPVOID)
|
||
{
|
||
switch (reason)
|
||
{
|
||
case DLL_PROCESS_ATTACH:
|
||
g_hDllInst = hDllInst;
|
||
::DisableThreadLibraryCalls(hDllInst);
|
||
#ifdef _DEBUG
|
||
MLZ_DbgInit((PSTR *) &c_apszDbgZones[0],
|
||
(sizeof(c_apszDbgZones) / sizeof(c_apszDbgZones[0])) - 1);
|
||
#endif
|
||
DBG_INIT_MEMORY_TRACKING(hDllInst);
|
||
::InitializeCriticalSection(&g_csPSTN);
|
||
break;
|
||
|
||
case DLL_PROCESS_DETACH:
|
||
::DeleteCriticalSection(&g_csPSTN);
|
||
DBG_CHECK_MEMORY_TRACKING(hDllInst);
|
||
#ifdef _DEBUG
|
||
MLZ_DbgDeInit();
|
||
#endif
|
||
break;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
TransportError WINAPI T123_CreateTransportInterface(ILegacyTransport **pp)
|
||
{
|
||
TransportError rc;
|
||
|
||
if (NULL != pp)
|
||
{
|
||
*pp = NULL;
|
||
|
||
if (NULL == g_pTransportInterface)
|
||
{
|
||
rc = TRANSPORT_MEMORY_FAILURE;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
g_pTransportInterface = new CTransportInterface(&rc);
|
||
if (NULL != g_pTransportInterface && TRANSPORT_NO_ERROR == rc)
|
||
{
|
||
*pp = (ILegacyTransport *) g_pTransportInterface;
|
||
return TRANSPORT_NO_ERROR;
|
||
}
|
||
|
||
delete g_pTransportInterface;
|
||
g_pTransportInterface = NULL;
|
||
return rc;
|
||
}
|
||
|
||
ASSERT(0);
|
||
return TRANSPORT_ALREADY_INITIALIZED;
|
||
}
|
||
|
||
return TRANSPORT_INVALID_PARAMETER;
|
||
}
|
||
|
||
|
||
CTransportInterface::CTransportInterface(TransportError *rc)
|
||
:
|
||
m_cUsers(0)
|
||
{
|
||
g_hWorkerThread = NULL;
|
||
g_dwWorkerThreadID = 0;
|
||
|
||
g_pfnT120Notify = NULL;
|
||
g_pUserData = NULL;
|
||
|
||
g_fEventListChanged = FALSE;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
g_pSystemTimer = new Timer;
|
||
ASSERT(NULL != g_pSystemTimer);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
g_hWorkerThreadEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
ASSERT(NULL != g_hWorkerThreadEvent);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
g_hThreadTerminateEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
|
||
ASSERT(NULL != g_hThreadTerminateEvent);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
g_pComPortList2 = new DictionaryClass(TRANSPORT_HASHING_BUCKETS);
|
||
ASSERT(NULL != g_pComPortList2);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
g_pPSTNEventList = new SListClass;
|
||
ASSERT(NULL != g_pPSTNEventList);
|
||
|
||
*rc = (g_pSystemTimer &&
|
||
g_hWorkerThreadEvent &&
|
||
g_hThreadTerminateEvent &&
|
||
g_pComPortList2 &&
|
||
g_pPSTNEventList)
|
||
?
|
||
TRANSPORT_NO_ERROR :
|
||
TRANSPORT_INITIALIZATION_FAILED;
|
||
ASSERT(TRANSPORT_NO_ERROR == *rc);
|
||
}
|
||
|
||
|
||
CTransportInterface::~CTransportInterface(void)
|
||
{
|
||
if (m_cUsers > 0)
|
||
{
|
||
// TCleanup() was not properly called enough times in the process.
|
||
// Force final cleanup.
|
||
m_cUsers = 1;
|
||
TCleanup();
|
||
}
|
||
|
||
delete g_pSystemTimer;
|
||
g_pSystemTimer = NULL;
|
||
|
||
delete g_pComPortList2;
|
||
g_pComPortList2 = NULL;
|
||
|
||
delete g_pPSTNEventList;
|
||
g_pPSTNEventList = NULL;
|
||
|
||
g_pfnT120Notify = NULL;
|
||
g_pUserData = NULL;
|
||
|
||
if (NULL != g_hWorkerThreadEvent)
|
||
{
|
||
::CloseHandle(g_hWorkerThreadEvent);
|
||
g_hWorkerThreadEvent = NULL;
|
||
}
|
||
|
||
if (NULL != g_hThreadTerminateEvent)
|
||
{
|
||
::CloseHandle(g_hThreadTerminateEvent);
|
||
g_hThreadTerminateEvent = NULL;
|
||
}
|
||
|
||
if (NULL != g_hWorkerThread)
|
||
{
|
||
::CloseHandle(g_hWorkerThread);
|
||
g_hWorkerThread = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
void CTransportInterface::ReleaseInterface(void)
|
||
{
|
||
delete this;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* TransportError APIENTRY TInitialize (
|
||
* TransportCallback transport_callback,
|
||
* PVoid user_defined)
|
||
*
|
||
* Functional Description:
|
||
* This function must be called by the user of the Transport
|
||
* stack. The PSTN thread is started.
|
||
*
|
||
* Caveats:
|
||
* If this function is successful, the user must also call the
|
||
* TCleanup() function when he is finished with the DLL.
|
||
*/
|
||
TransportError CTransportInterface::TInitialize
|
||
(
|
||
TransportCallback transport_callback,
|
||
void *user_defined
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NO_ERROR;
|
||
|
||
if (! m_cUsers)
|
||
{
|
||
g_pfnT120Notify = transport_callback;
|
||
g_pUserData = user_defined;
|
||
|
||
/*
|
||
** At this point, we need to create another thread that will
|
||
** maintain this DLL.
|
||
*/
|
||
g_hWorkerThread = ::CreateThread(
|
||
NULL, 0, (LPTHREAD_START_ROUTINE) T123_WorkerThreadProc,
|
||
NULL, 0, &g_dwWorkerThreadID);
|
||
if (NULL != g_hWorkerThread)
|
||
{
|
||
if (::SetThreadPriority(g_hWorkerThread, THREAD_PRIORITY_ABOVE_NORMAL) == FALSE)
|
||
{
|
||
WARNING_OUT(("SetThreadPriority ERROR: = %d", ::GetLastError()));
|
||
}
|
||
|
||
/*
|
||
** Wait for the secondary thread to notify us that initialization is
|
||
** complete
|
||
*/
|
||
::WaitForSingleObject(g_hWorkerThreadEvent, 30000); // 30 seconds
|
||
|
||
/*
|
||
** If g_pController == NULL, initialization FAILED. We use
|
||
** this variable to signal us regarding the status of the secondary
|
||
** thread.
|
||
*/
|
||
if (NULL == g_pController)
|
||
{
|
||
ERROR_OUT(("TInitialize: Unable to initialize transport"));
|
||
rc = TRANSPORT_INITIALIZATION_FAILED;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rc = TRANSPORT_INITIALIZATION_FAILED;
|
||
}
|
||
}
|
||
|
||
if (TRANSPORT_NO_ERROR == rc)
|
||
{
|
||
m_cUsers++;
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError TCleanup (void)
|
||
*
|
||
* Functional Description:
|
||
* This function is called to release all system resources that
|
||
* were used during the life of the DLL.
|
||
*
|
||
* Caveats:
|
||
* This function should only be called if the user had previously
|
||
* called the TInitialize() function.
|
||
*/
|
||
TransportError CTransportInterface::TCleanup(void)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
if (--m_cUsers == 0)
|
||
{
|
||
/*
|
||
** Set the g_hThreadTerminateEvent to notify the PSTN thread
|
||
** that it should terminate operations.
|
||
*/
|
||
::SetEvent(g_hThreadTerminateEvent);
|
||
|
||
/*
|
||
** Wait for the PSTN thread to notify us that cleanup is
|
||
** complete
|
||
*/
|
||
if (g_hWorkerThreadEvent != NULL)
|
||
{
|
||
// WaitForSingleObject (g_hWorkerThreadEvent, INFINITE);
|
||
::WaitForSingleObject(g_hWorkerThreadEvent, 30000); // 30 seconds
|
||
g_hWorkerThreadEvent = NULL;
|
||
|
||
//
|
||
// Relinquish the remainder of our time slice, to allow trasnsport thread to exit.
|
||
//
|
||
Sleep(0);
|
||
}
|
||
}
|
||
|
||
rc = TRANSPORT_NO_ERROR;
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
TransportError CTransportInterface::TCreateTransportStack
|
||
(
|
||
BOOL fCaller,
|
||
HANDLE hCommLink,
|
||
HANDLE hevtClose,
|
||
PLUGXPRT_PARAMETERS *pParams
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
if (NULL != g_pController)
|
||
{
|
||
rc = g_pController->CreateTransportStack(fCaller, hCommLink, hevtClose, pParams);
|
||
}
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
TransportError CTransportInterface::TCloseTransportStack
|
||
(
|
||
HANDLE hCommLink
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
if (NULL != g_pController)
|
||
{
|
||
rc = g_pController->CloseTransportStack(hCommLink);
|
||
}
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError APIENTRY TConnectRequest (
|
||
* TransportAddress transport_address,
|
||
* TransportPriority transport_priority,
|
||
* LogicalHandle *logical_handle)
|
||
*
|
||
* Functional Description:
|
||
* This function starts the process of building a transport connection.
|
||
* It uses the transport_address and attempts to make a connection to it.
|
||
*
|
||
* If the DLL is set up for in-band call control, the DLL will choose a
|
||
* modem and attempt a connection. After the physical connection is up,
|
||
* it will create a logical connection that the user application can use.
|
||
*
|
||
* If the DLL is set up for out-of-band call control, the transport address
|
||
* is actually an ascii string that represents a DLL generated
|
||
* physicalhandle. This call can only be made in response to a successful
|
||
* TPhysicalConnectRequest() function. The TPhysicalConnectRequest() call
|
||
* returns a PhysicalHandle that the user must convert to ascii and pass
|
||
* back to the DLL via this call. Although this is very ugly, we did this
|
||
* for a reason. We added the out-of-band call control API to the
|
||
* transports but we did not want to change GCC or MCS to do it. GCC and
|
||
* MCS already expected an ascii string as the transport address. In the
|
||
* future, look for this to change in MCS and GCC.
|
||
*/
|
||
TransportError CTransportInterface::TConnectRequest
|
||
(
|
||
LEGACY_HANDLE *logical_handle,
|
||
HANDLE hCommLink
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
if (NULL != g_pController)
|
||
{
|
||
rc = g_pController->ConnectRequest(logical_handle, hCommLink);
|
||
}
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError APIENTRY TDisconnectRequest (
|
||
* LogicalHandle logical_handle,
|
||
* BOOL trash_packets)
|
||
*
|
||
* Functional Description:
|
||
* This function breaks a logical connection. This is also an X.214
|
||
* primitive. Since the DLL may have packets queued up for transmission
|
||
* for this logical connection, the trash_packets parameter determines
|
||
* whether the DLL should trash those packets before disconnecting the
|
||
* logical connection.
|
||
*/
|
||
TransportError CTransportInterface::TDisconnectRequest
|
||
(
|
||
LEGACY_HANDLE logical_handle,
|
||
BOOL trash_packets
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
if (NULL != g_pController)
|
||
{
|
||
rc = g_pController->DisconnectRequest(logical_handle, trash_packets);
|
||
}
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError APIENTRY TDataRequest (
|
||
* LogicalHandle logical_handle,
|
||
* LPBYTE user_data,
|
||
* ULONG user_data_length)
|
||
*
|
||
* Functional Description:
|
||
* This function takes the data passed in and attempts to send it
|
||
* to the remote site.
|
||
*/
|
||
TransportError CTransportInterface::TDataRequest
|
||
(
|
||
LEGACY_HANDLE logical_handle,
|
||
LPBYTE user_data,
|
||
ULONG user_data_length
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
|
||
if (NULL != g_pController)
|
||
{
|
||
rc = g_pController->DataRequest(logical_handle, user_data, user_data_length);
|
||
/*
|
||
** If the packet was accepted, we need to issue a
|
||
** PollTransmitter() to flush the packet out. Otherwise,
|
||
** we will have a latency problem.
|
||
*/
|
||
if (TRANSPORT_NO_ERROR == rc)
|
||
{
|
||
ComPort *comport;
|
||
PhysicalHandle physical_handle = g_pController->GetPhysicalHandle(logical_handle);
|
||
if (g_pComPortList2->find((DWORD_PTR) physical_handle, (PDWORD_PTR) &comport))
|
||
{
|
||
if (! comport->IsWriteActive())
|
||
{
|
||
g_pController->PollTransmitter(physical_handle);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError APIENTRY TReceiveBufferAvailable (void)
|
||
*
|
||
* Functional Description:
|
||
* This function informs the transport to enable packet transfer from the
|
||
* Transport to the user application. This function makes a call to
|
||
* 'Enable' the receiver and then it issues a PollReceiver() to actually
|
||
* allow any pending packets to be sent on up to the user.
|
||
*/
|
||
TransportError CTransportInterface::TReceiveBufferAvailable(void)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
|
||
if (NULL != g_pController)
|
||
{
|
||
g_pController->EnableReceiver();
|
||
g_pController->PollReceiver();
|
||
|
||
/*
|
||
** We are doing a PollTransmitter() here to allow
|
||
** the Q922 object to exit the 'receiver not ready' mode.
|
||
** If MCS had been rejecting packets, and now it is accepting
|
||
** packets, we need to let the remote site know that it
|
||
** can re-start its transmitter.
|
||
*/
|
||
g_pController->PollTransmitter();
|
||
}
|
||
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
|
||
rc = TRANSPORT_NO_ERROR;
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError APIENTRY TPurgeRequest (
|
||
* LogicalHandle logical_handle)
|
||
*
|
||
* Functional Description:
|
||
* This function purges all of the outbound packets for the given
|
||
* logical connection.
|
||
*/
|
||
TransportError CTransportInterface::TPurgeRequest
|
||
(
|
||
LEGACY_HANDLE logical_handle
|
||
)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
if (NULL != g_pController)
|
||
{
|
||
rc = g_pController->PurgeRequest(logical_handle);
|
||
}
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
TransportError CTransportInterface::TEnableReceiver(void)
|
||
{
|
||
TransportError rc = TRANSPORT_NOT_INITIALIZED;
|
||
|
||
if (m_cUsers > 0)
|
||
{
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
if (NULL != g_pController)
|
||
{
|
||
g_pController->EnableReceiver();
|
||
}
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
}
|
||
|
||
return TRANSPORT_NO_ERROR;
|
||
}
|
||
|
||
|
||
/*
|
||
* DWORD T123_WorkerThreadProc (LPDWORD)
|
||
*
|
||
* Functional Description:
|
||
* This function is the PSTN thread. It maintains the DLL.
|
||
*/
|
||
DWORD T123_WorkerThreadProc(DWORD *)
|
||
{
|
||
PEventObject event_struct;
|
||
BOOL fContinue = TRUE;
|
||
HANDLE aEvents[TPRTINTF_MAXIMUM_WAIT_OBJECTS];
|
||
ULONG cEvents;
|
||
ULONG last_time_polled;
|
||
ULONG current_time;
|
||
|
||
g_fEventListChanged = FALSE;
|
||
|
||
/*
|
||
** Create the one and only instance of the Transport Controller
|
||
** to be in charge of this DLL. Once it is created, all other
|
||
** primitives are routed to it.
|
||
*/
|
||
DBG_SAVE_FILE_LINE
|
||
g_pController = new TransportController();
|
||
if (g_pController == NULL)
|
||
{
|
||
ERROR_OUT(("PSTN_WorkerThreadProc: cannot allocate TransportController"));
|
||
::SetEvent(g_hWorkerThreadEvent);
|
||
return TRANSPORT_INITIALIZATION_FAILED;
|
||
}
|
||
|
||
/*
|
||
** The DLL needs to be polled every X milliseconds. We do this
|
||
** by checking the system clock and if X milliseconds have elapsed
|
||
** since the last DLL poll, we do it again. This line of code is
|
||
** actually initializing the timer.
|
||
*/
|
||
last_time_polled = ::GetTickCount();
|
||
|
||
/*
|
||
** Notify the primary thread that we are up
|
||
*/
|
||
::SetEvent(g_hWorkerThreadEvent);
|
||
|
||
|
||
// THREAD LOOP
|
||
|
||
/*
|
||
** This while loop is the heart of the PSTN thread. We use the
|
||
** WaitForMultipleObjects() function to wake up our thread when a
|
||
** significant event occurs OR when a timeout occurs.
|
||
**
|
||
** There are four different types of event objects that can occur
|
||
** that will wake up the thread.
|
||
**
|
||
** 1. The primary thread sets the g_hThreadTerminateEvent object.
|
||
** 2. Read event from the ComPort object. If a read of a comm port
|
||
** completes or times out, the event object is set
|
||
** 3. Write event from the ComPort object. If a write on a comm
|
||
** port completes or times out.
|
||
** 4. Control event from the ComPort object. If the carrier detect
|
||
** signal changes.
|
||
**
|
||
** Also, the thread will continue running if the MCATPSTN_TIMER_DURATION
|
||
** expires
|
||
**
|
||
**
|
||
** A ComPort object can add event objects to our PSTN Event_List at any
|
||
** time. When they are added to the Event_List, we add them to the
|
||
** local aEvents and the WaitForMultipleObjects() function waits
|
||
** for them.
|
||
**
|
||
** This approach works very well except that the WaitForMultipleObjects()
|
||
** function can only handle TPRTINTF_MAXIMUM_WAIT_OBJECTS at a time. Currently,
|
||
** this #define is set to 64 by the Windows 95 operating system. Since
|
||
** each ComPort uses 3 event objects, this limits us to a maximum of
|
||
** 21 active ports.
|
||
*/
|
||
aEvents[0] = g_hThreadTerminateEvent;
|
||
cEvents = 1;
|
||
|
||
while (fContinue)
|
||
{
|
||
/*
|
||
** Wait for an event to occur or for the timeout to expire
|
||
*/
|
||
DWORD dwRet = ::WaitForMultipleObjects(cEvents, aEvents, FALSE, MCATPSTN_TIMER_DURATION);
|
||
|
||
/*
|
||
** We MUST enter this critical section of code and lock out the
|
||
** primary thread from enterring it. Both threads executing this
|
||
** code could be disasterous
|
||
*/
|
||
::EnterCriticalSection(&g_csPSTN);
|
||
|
||
if (dwRet == WAIT_FAILED)
|
||
{
|
||
fContinue = FALSE;
|
||
break;
|
||
}
|
||
else
|
||
if (dwRet == WAIT_TIMEOUT)
|
||
{
|
||
if (cEvents > 1)
|
||
{
|
||
last_time_polled = ::GetTickCount();
|
||
g_pController->PollReceiver();
|
||
g_pController->PollTransmitter();
|
||
g_pSystemTimer->ProcessTimerEvents();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Determine which object has signalled us
|
||
*/
|
||
ULONG dwIdx = dwRet - WAIT_OBJECT_0;
|
||
if (dwIdx > cEvents)
|
||
{
|
||
ERROR_OUT(("ThreadFunc: Invalid object signalled = %d", dwIdx));
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** If the object that signalled us is index 0, it is the
|
||
** terminate thread object.
|
||
*/
|
||
if (! dwIdx)
|
||
{
|
||
TRACE_OUT(("ThreadFunc: Terminating thread"));
|
||
fContinue = FALSE;
|
||
}
|
||
else
|
||
{
|
||
dwIdx--;
|
||
event_struct = (PEventObject) g_pPSTNEventList->read((USHORT) dwIdx);
|
||
if (NULL != event_struct)
|
||
{
|
||
/*
|
||
** Check the delete_event, if it is set, we need to
|
||
** terminate the event.
|
||
**
|
||
** By design, other objects throughout the DLL create
|
||
** the events, and this function deletes them. If the
|
||
** creating function deleted them, we could be waiting
|
||
** on an event that gets deleted. That has the potential
|
||
** of being messy.
|
||
*/
|
||
if (event_struct->delete_event)
|
||
{
|
||
/*
|
||
** Remove the ComPort from our list
|
||
*/
|
||
ComPort *comport = NULL;
|
||
if (g_pComPortList2->find((DWORD_PTR) event_struct->hCommLink, (PDWORD_PTR) &comport))
|
||
{
|
||
g_pComPortList2->remove((DWORD_PTR) event_struct->hCommLink);
|
||
comport->Release();
|
||
}
|
||
|
||
/*
|
||
** Close the event
|
||
*/
|
||
::CloseHandle(event_struct->event);
|
||
|
||
/*
|
||
** Remove the event from our list
|
||
*/
|
||
g_pPSTNEventList->remove((DWORD_PTR) event_struct);
|
||
delete event_struct;
|
||
|
||
g_fEventListChanged = TRUE;
|
||
}
|
||
else
|
||
{
|
||
ComPort *comport = event_struct->comport;
|
||
/*
|
||
** Switch on the event_type to determine the
|
||
** operation that needs to take place
|
||
*/
|
||
switch (event_struct->event_type)
|
||
{
|
||
case READ_EVENT:
|
||
comport->ProcessReadEvent();
|
||
|
||
/*
|
||
** If a READ event occurred, we need to issue
|
||
** a PollReceiver() and then issue a
|
||
** PollTransmitter(). We issue the
|
||
** PollTransmitter() because the PollReceiver()
|
||
** may have freed up space for us to send out
|
||
** data.
|
||
*/
|
||
g_pController->PollReceiver(event_struct->hCommLink);
|
||
g_pController->PollTransmitter(event_struct->hCommLink);
|
||
break;
|
||
|
||
case WRITE_EVENT:
|
||
/*
|
||
** If a WRITE_EVENT occurs, this means that
|
||
** space has become available to transmit more
|
||
** data.
|
||
*/
|
||
comport->ProcessWriteEvent();
|
||
g_pController->PollTransmitter(event_struct->hCommLink);
|
||
break;
|
||
|
||
case CONTROL_EVENT:
|
||
/*
|
||
** The CONTROL events are particular to the
|
||
** ComPort object. A change in the CD signal
|
||
** could be a CONTROL event.
|
||
*/
|
||
g_pController->PollReceiver(event_struct->hCommLink);
|
||
break;
|
||
|
||
default:
|
||
ERROR_OUT(("ThreadFunc: Illegal event type = %d", event_struct->event_type));
|
||
break;
|
||
} // switch
|
||
}
|
||
} // if event_struct
|
||
}
|
||
}
|
||
|
||
/*
|
||
** Check to see if enough time has elapsed since the last time we
|
||
** polled the DLL to do it again.
|
||
*/
|
||
if (cEvents > 1)
|
||
{
|
||
current_time = ::GetTickCount();
|
||
if ((current_time - last_time_polled) >= MCATPSTN_TIMER_DURATION)
|
||
{
|
||
last_time_polled = current_time;
|
||
|
||
g_pController->PollReceiver();
|
||
g_pController->PollTransmitter();
|
||
g_pSystemTimer->ProcessTimerEvents();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
** This Event_List_Changed will only be set to TRUE if we need to
|
||
** update our event list
|
||
*/
|
||
if (g_fEventListChanged)
|
||
{
|
||
aEvents[0] = g_hThreadTerminateEvent;
|
||
cEvents = 1;
|
||
|
||
if (g_pPSTNEventList->entries() > (TPRTINTF_MAXIMUM_WAIT_OBJECTS - 1))
|
||
{
|
||
ERROR_OUT(("ThreadFunc: ERROR: Number of event objects = %d",
|
||
g_pPSTNEventList->entries() + 1));
|
||
}
|
||
|
||
/*
|
||
** Go thru the Event_List and create a new aEvents.
|
||
*/
|
||
g_pPSTNEventList->reset();
|
||
while (g_pPSTNEventList->iterate((PDWORD_PTR) &event_struct))
|
||
{
|
||
aEvents[cEvents] = event_struct -> event;
|
||
cEvents++;
|
||
|
||
/*
|
||
** Add the physical_handle to the ComPort_List
|
||
*/
|
||
if (event_struct->event_type == WRITE_EVENT)
|
||
{
|
||
if (! g_pComPortList2->find((DWORD_PTR) event_struct->hCommLink))
|
||
{
|
||
g_pComPortList2->insert((DWORD_PTR) event_struct->hCommLink,
|
||
(DWORD_PTR) event_struct->comport);
|
||
}
|
||
}
|
||
}
|
||
g_fEventListChanged = FALSE;
|
||
}
|
||
|
||
::LeaveCriticalSection(&g_csPSTN);
|
||
} // while
|
||
|
||
|
||
// CLEANUP THE THREAD RESOURCES
|
||
delete g_pController;
|
||
g_pController = NULL;
|
||
|
||
/*
|
||
** Delete all of the event objects
|
||
*/
|
||
g_pPSTNEventList->reset();
|
||
while (g_pPSTNEventList->iterate((PDWORD_PTR) &event_struct))
|
||
{
|
||
::CloseHandle(event_struct->event);
|
||
delete event_struct;
|
||
}
|
||
|
||
/*
|
||
** Notify the primary thread that we are up
|
||
*/
|
||
::SetEvent(g_hWorkerThreadEvent);
|
||
|
||
return (0);
|
||
}
|
||
|
||
|
||
|
||
ULONG NotifyT120(ULONG msg, void *param)
|
||
{
|
||
if (NULL != g_pfnT120Notify)
|
||
{
|
||
return (*g_pfnT120Notify) (msg, param, g_pUserData);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
IObject::~IObject(void) { }
|
||
|
||
|