|
|
#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) { }
|
