985 lines
27 KiB
C
985 lines
27 KiB
C
|
/*++
|
||
|
|
|
||
|
|
Copyright (c) 1998-1999 Microsoft Corporation
|
||
|
|
|
||
|
|
Module Name:
|
||
|
|
|
||
|
|
utils.h
|
||
|
|
|
||
|
|
Abstract:
|
||
|
|
|
||
|
|
Author:
|
||
|
|
|
||
|
|
mquinton 06-30-98
|
||
|
|
|
||
|
|
Notes:
|
||
|
|
|
||
|
|
Revision History:
|
||
|
|
|
||
|
|
--*/
|
||
|
|
|
||
|
|
#ifndef __UTILS_H__
|
||
|
|
#define __UTILS_H__
|
||
|
|
|
||
|
|
#ifdef TRACELOG
|
||
|
|
|
||
|
|
#include <rtutils.h>
|
||
|
|
//#include <windef.h>
|
||
|
|
//#include <winnt.h>
|
||
|
|
|
||
|
|
extern BOOL g_bLoggingEnabled;
|
||
|
|
|
||
|
|
#define MAXDEBUGSTRINGLENGTH 1024
|
||
|
|
|
||
|
|
#define TL_ERROR ((DWORD)0x00010000 | TRACE_USE_MASK)
|
||
|
|
#define TL_WARN ((DWORD)0x00020000 | TRACE_USE_MASK)
|
||
|
|
#define TL_INFO ((DWORD)0x00040000 | TRACE_USE_MASK)
|
||
|
|
#define TL_TRACE ((DWORD)0x00080000 | TRACE_USE_MASK)
|
||
|
|
#define TL_EVENT ((DWORD)0x00100000 | TRACE_USE_MASK)
|
||
|
|
|
||
|
|
BOOL TRACELogRegister(LPCTSTR szName);
|
||
|
|
void TRACELogDeRegister();
|
||
|
|
void TRACELogPrint(IN DWORD dwDbgLevel, IN LPCSTR DbgMessage, IN ...);
|
||
|
|
void TRACELogPrint(IN DWORD dwDbgLevel, HRESULT hr, IN LPCSTR lpszFormat, IN ...);
|
||
|
|
|
||
|
|
extern char *TraceLevel(DWORD dwDbgLevel);
|
||
|
|
extern void TAPIFormatMessage(HRESULT hr, LPVOID lpMsgBuf);
|
||
|
|
|
||
|
|
#define TRACELOGREGISTER(arg) TRACELogRegister(arg)
|
||
|
|
#define TRACELOGDEREGISTER() g_bLoggingEnabled?TRACELogDeRegister():0
|
||
|
|
#define LOG(arg) g_bLoggingEnabled?TRACELogPrint arg:0
|
||
|
|
#define STATICLOG(arg) g_bLoggingEnabled?StaticTRACELogPrint arg:0
|
||
|
|
|
||
|
|
extern char sg_szTraceName[100];
|
||
|
|
extern DWORD sg_dwTracingToDebugger;
|
||
|
|
extern DWORD sg_dwDebuggerMask;
|
||
|
|
extern DWORD sg_dwTraceID;
|
||
|
|
|
||
|
|
#define DECLARE_DEBUG_ADDREF_RELEASE(x) \
|
||
|
|
void LogDebugAddRef(DWORD dw) \
|
||
|
|
{ TRACELogPrint(TL_INFO, "%s::AddRef() = %d - this %lx", _T(#x), dw, this); } \
|
||
|
|
void LogDebugRelease(DWORD dw) \
|
||
|
|
{ TRACELogPrint(TL_INFO, "%s::Release() = %d - this %lx", _T(#x), dw, this); }
|
||
|
|
|
||
|
|
|
||
|
|
#define DECLARE_TRACELOG_CLASS(x) \
|
||
|
|
void TRACELogPrint(IN DWORD dwDbgLevel, IN LPCSTR lpszFormat, IN ...) \
|
||
|
|
{ \
|
||
|
|
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
|
||
|
|
va_list arglist; \
|
||
|
|
\
|
||
|
|
if ( ( sg_dwTracingToDebugger > 0 ) && \
|
||
|
|
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
|
||
|
|
{ \
|
||
|
|
SYSTEMTIME SystemTime; \
|
||
|
|
GetLocalTime(&SystemTime); \
|
||
|
|
\
|
||
|
|
wsprintfA(szTraceBuf, \
|
||
|
|
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] (%p) %s::", \
|
||
|
|
sg_szTraceName, \
|
||
|
|
SystemTime.wHour, \
|
||
|
|
SystemTime.wMinute, \
|
||
|
|
SystemTime.wSecond, \
|
||
|
|
SystemTime.wMilliseconds, \
|
||
|
|
GetCurrentThreadId(), \
|
||
|
|
TraceLevel(dwDbgLevel), \
|
||
|
|
this, \
|
||
|
|
_T(#x)); \
|
||
|
|
\
|
||
|
|
va_list ap; \
|
||
|
|
va_start(ap, lpszFormat); \
|
||
|
|
\
|
||
|
|
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
|
||
|
|
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
|
||
|
|
lpszFormat, \
|
||
|
|
ap \
|
||
|
|
); \
|
||
|
|
\
|
||
|
|
lstrcatA (szTraceBuf, "\n"); \
|
||
|
|
\
|
||
|
|
OutputDebugStringA (szTraceBuf); \
|
||
|
|
\
|
||
|
|
va_end(ap); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
if (sg_dwTraceID != INVALID_TRACEID) \
|
||
|
|
{ \
|
||
|
|
wsprintfA(szTraceBuf, "[%s] (%p) %s::%s", TraceLevel(dwDbgLevel), this, _T(#x), lpszFormat); \
|
||
|
|
\
|
||
|
|
va_start(arglist, lpszFormat); \
|
||
|
|
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
|
||
|
|
va_end(arglist); \
|
||
|
|
} \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
void TRACELogPrint(IN DWORD dwDbgLevel,IN HRESULT hr, IN LPCSTR lpszFormat, IN ...) \
|
||
|
|
{ \
|
||
|
|
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
|
||
|
|
LPVOID lpMsgBuf = NULL; \
|
||
|
|
va_list arglist; \
|
||
|
|
\
|
||
|
|
TAPIFormatMessage(hr, &lpMsgBuf); \
|
||
|
|
\
|
||
|
|
if ( ( sg_dwTracingToDebugger > 0 ) && \
|
||
|
|
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
|
||
|
|
{ \
|
||
|
|
SYSTEMTIME SystemTime; \
|
||
|
|
GetLocalTime(&SystemTime); \
|
||
|
|
\
|
||
|
|
wsprintfA(szTraceBuf, \
|
||
|
|
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] (%p) %s::", \
|
||
|
|
sg_szTraceName, \
|
||
|
|
SystemTime.wHour, \
|
||
|
|
SystemTime.wMinute, \
|
||
|
|
SystemTime.wSecond, \
|
||
|
|
SystemTime.wMilliseconds, \
|
||
|
|
GetCurrentThreadId(), \
|
||
|
|
TraceLevel(dwDbgLevel), \
|
||
|
|
this, \
|
||
|
|
_T(#x) \
|
||
|
|
); \
|
||
|
|
\
|
||
|
|
va_list ap; \
|
||
|
|
va_start(ap, lpszFormat); \
|
||
|
|
\
|
||
|
|
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
|
||
|
|
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
|
||
|
|
lpszFormat, \
|
||
|
|
ap \
|
||
|
|
); \
|
||
|
|
\
|
||
|
|
wsprintfA(&szTraceBuf[lstrlenA(szTraceBuf)], \
|
||
|
|
" Returned[%lx] %s\n", \
|
||
|
|
hr, \
|
||
|
|
lpMsgBuf); \
|
||
|
|
\
|
||
|
|
OutputDebugStringA (szTraceBuf); \
|
||
|
|
\
|
||
|
|
va_end(ap); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
if (sg_dwTraceID != INVALID_TRACEID) \
|
||
|
|
{ \
|
||
|
|
wsprintfA(szTraceBuf, "[%s] (%p) %s::%s Returned[%lx] %s", TraceLevel(dwDbgLevel), this, _T(#x), lpszFormat,hr, lpMsgBuf ); \
|
||
|
|
\
|
||
|
|
va_start(arglist, lpszFormat); \
|
||
|
|
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
|
||
|
|
va_end(arglist); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
if(lpMsgBuf != NULL) \
|
||
|
|
{ \
|
||
|
|
LocalFree( lpMsgBuf ); \
|
||
|
|
} \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
static void StaticTRACELogPrint(IN DWORD dwDbgLevel, IN LPCSTR lpszFormat, IN ...) \
|
||
|
|
{ \
|
||
|
|
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
|
||
|
|
va_list arglist; \
|
||
|
|
\
|
||
|
|
if ( ( sg_dwTracingToDebugger > 0 ) && \
|
||
|
|
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
|
||
|
|
{ \
|
||
|
|
SYSTEMTIME SystemTime; \
|
||
|
|
GetLocalTime(&SystemTime); \
|
||
|
|
\
|
||
|
|
wsprintfA(szTraceBuf, \
|
||
|
|
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] %s::", \
|
||
|
|
sg_szTraceName, \
|
||
|
|
SystemTime.wHour, \
|
||
|
|
SystemTime.wMinute, \
|
||
|
|
SystemTime.wSecond, \
|
||
|
|
SystemTime.wMilliseconds, \
|
||
|
|
GetCurrentThreadId(), \
|
||
|
|
TraceLevel(dwDbgLevel), \
|
||
|
|
_T(#x)); \
|
||
|
|
\
|
||
|
|
va_list ap; \
|
||
|
|
va_start(ap, lpszFormat); \
|
||
|
|
\
|
||
|
|
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
|
||
|
|
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
|
||
|
|
lpszFormat, \
|
||
|
|
ap \
|
||
|
|
); \
|
||
|
|
\
|
||
|
|
lstrcatA (szTraceBuf, "\n"); \
|
||
|
|
\
|
||
|
|
OutputDebugStringA (szTraceBuf); \
|
||
|
|
\
|
||
|
|
va_end(ap); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
if (sg_dwTraceID != INVALID_TRACEID) \
|
||
|
|
{ \
|
||
|
|
wsprintfA(szTraceBuf, "[%s] %s::%s", TraceLevel(dwDbgLevel), _T(#x), lpszFormat); \
|
||
|
|
\
|
||
|
|
va_start(arglist, lpszFormat); \
|
||
|
|
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
|
||
|
|
va_end(arglist); \
|
||
|
|
} \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
static void StaticTRACELogPrint(IN DWORD dwDbgLevel,IN HRESULT hr, IN LPCSTR lpszFormat, IN ...) \
|
||
|
|
{ \
|
||
|
|
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
|
||
|
|
LPVOID lpMsgBuf = NULL; \
|
||
|
|
va_list arglist; \
|
||
|
|
\
|
||
|
|
TAPIFormatMessage(hr, &lpMsgBuf); \
|
||
|
|
\
|
||
|
|
if ( ( sg_dwTracingToDebugger > 0 ) && \
|
||
|
|
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
|
||
|
|
{ \
|
||
|
|
SYSTEMTIME SystemTime; \
|
||
|
|
GetLocalTime(&SystemTime); \
|
||
|
|
\
|
||
|
|
wsprintfA(szTraceBuf, \
|
||
|
|
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] %s::", \
|
||
|
|
sg_szTraceName, \
|
||
|
|
SystemTime.wHour, \
|
||
|
|
SystemTime.wMinute, \
|
||
|
|
SystemTime.wSecond, \
|
||
|
|
SystemTime.wMilliseconds, \
|
||
|
|
GetCurrentThreadId(), \
|
||
|
|
TraceLevel(dwDbgLevel), \
|
||
|
|
_T(#x) \
|
||
|
|
); \
|
||
|
|
\
|
||
|
|
va_list ap; \
|
||
|
|
va_start(ap, lpszFormat); \
|
||
|
|
\
|
||
|
|
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
|
||
|
|
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
|
||
|
|
lpszFormat, \
|
||
|
|
ap \
|
||
|
|
); \
|
||
|
|
\
|
||
|
|
wsprintfA(&szTraceBuf[lstrlenA(szTraceBuf)], \
|
||
|
|
" Returned[%lx] %s\n", \
|
||
|
|
hr, \
|
||
|
|
lpMsgBuf); \
|
||
|
|
\
|
||
|
|
OutputDebugStringA (szTraceBuf); \
|
||
|
|
\
|
||
|
|
va_end(ap); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
if (sg_dwTraceID != INVALID_TRACEID) \
|
||
|
|
{ \
|
||
|
|
wsprintfA(szTraceBuf, "[%s] %s::%s Returned[%lx] %s", TraceLevel(dwDbgLevel), _T(#x), lpszFormat,hr, lpMsgBuf ); \
|
||
|
|
\
|
||
|
|
va_start(arglist, lpszFormat); \
|
||
|
|
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
|
||
|
|
va_end(arglist); \
|
||
|
|
} \
|
||
|
|
\
|
||
|
|
if(lpMsgBuf != NULL) \
|
||
|
|
{ \
|
||
|
|
LocalFree( lpMsgBuf ); \
|
||
|
|
} \
|
||
|
|
}
|
||
|
|
|
||
|
|
#else // TRACELOG not defined
|
||
|
|
|
||
|
|
#define TRACELOGREGISTER(arg)
|
||
|
|
#define TRACELOGDEREGISTER()
|
||
|
|
#define LOG(arg)
|
||
|
|
#define STATICLOG(arg)
|
||
|
|
#define DECLARE_DEBUG_ADDREF_RELEASE(x)
|
||
|
|
#define DECLARE_TRACELOG_CLASS(x)
|
||
|
|
|
||
|
|
#endif // TRACELOG
|
||
|
|
|
||
|
|
class CAsyncRequestReply
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
HANDLE hRepliedSemaphore;
|
||
|
|
DWORD dwID;
|
||
|
|
BOOL bReply;
|
||
|
|
HRESULT hResult;
|
||
|
|
|
||
|
|
public:
|
||
|
|
DECLARE_TRACELOG_CLASS(CAsyncRequestReply)
|
||
|
|
CAsyncRequestReply(DWORD id, BOOL b, HRESULT hr)
|
||
|
|
{
|
||
|
|
if( (hRepliedSemaphore = CreateSemaphore(NULL,0,1,NULL)) == NULL )
|
||
|
|
{
|
||
|
|
LOG((TL_INFO, "create CAsyncRequest - CreateSemaphore failed"));
|
||
|
|
hResult = E_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
dwID = id;
|
||
|
|
bReply = b;
|
||
|
|
hResult = hr;
|
||
|
|
LOG((TL_INFO, "create CAsyncRequest %d ",dwID));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
~CAsyncRequestReply()
|
||
|
|
{
|
||
|
|
LOG((TL_INFO, "delete CAsyncRequest %d ",dwID));
|
||
|
|
|
||
|
|
if( NULL != hRepliedSemaphore )
|
||
|
|
{
|
||
|
|
CloseHandle(hRepliedSemaphore);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inline DWORD getID() {return dwID;};
|
||
|
|
inline BOOL IsReply() {return bReply;};
|
||
|
|
inline HRESULT getResult() {return hResult;};
|
||
|
|
inline void setResult(HRESULT hr) {hResult = hr;};
|
||
|
|
|
||
|
|
HRESULT wait()
|
||
|
|
{
|
||
|
|
LOG((TL_INFO, "wait CAsyncRequest %d ",dwID));
|
||
|
|
|
||
|
|
extern DWORD gdwTapi2AsynchronousCallTimeout;
|
||
|
|
|
||
|
|
DWORD rc = WaitForSingleObject(hRepliedSemaphore, gdwTapi2AsynchronousCallTimeout);
|
||
|
|
|
||
|
|
switch (rc)
|
||
|
|
{
|
||
|
|
case WAIT_ABANDONED:
|
||
|
|
LOG((TL_ERROR, "wait CAsyncRequest %d WaitForSingle object returned WAIT_ABANDONED",dwID));
|
||
|
|
hResult = TAPIERR_REQUESTFAILED;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WAIT_OBJECT_0:
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WAIT_TIMEOUT:
|
||
|
|
LOG((TL_WARN, "wait CAsyncRequest %d WaitForSingle object returned WAIT_TIMEOUT",dwID));
|
||
|
|
// -1 won't overlap with any value that may be returned from tapi2 calls.
|
||
|
|
hResult = -1;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WAIT_FAILED:
|
||
|
|
{
|
||
|
|
DWORD nLastError = GetLastError();
|
||
|
|
LOG((TL_ERROR, "wait CAsyncRequest %d WaitForSingle object returned WAIT_FAILED, LastError = %d", dwID, nLastError));
|
||
|
|
hResult = TAPIERR_REQUESTFAILED;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
return hResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
void signal()
|
||
|
|
{
|
||
|
|
LOG((TL_INFO, "signal CAsyncRequest %d ",dwID));
|
||
|
|
ReleaseSemaphore(hRepliedSemaphore, 1, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
typedef list<CAsyncRequestReply *> RequestReplyList;
|
||
|
|
|
||
|
|
class CAsyncReplyList
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
DECLARE_TRACELOG_CLASS(CAsyncReplyList)
|
||
|
|
private:
|
||
|
|
RequestReplyList replyList;
|
||
|
|
CRITICAL_SECTION csReply;
|
||
|
|
|
||
|
|
CAsyncRequestReply *find(DWORD dwID)
|
||
|
|
{
|
||
|
|
RequestReplyList::iterator i;
|
||
|
|
CAsyncRequestReply *pResult = NULL;
|
||
|
|
|
||
|
|
// walk list searching for match
|
||
|
|
i = replyList.begin();
|
||
|
|
// iterate over current replies
|
||
|
|
while ( i != replyList.end() )
|
||
|
|
{
|
||
|
|
// found it
|
||
|
|
if ((*i)->getID() == dwID )
|
||
|
|
{
|
||
|
|
pResult = *i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
//returning pointer to matching entry or NULL
|
||
|
|
return pResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
public:
|
||
|
|
CAsyncReplyList() {InitializeCriticalSection( &csReply );};
|
||
|
|
|
||
|
|
~CAsyncReplyList()
|
||
|
|
{
|
||
|
|
FreeList();
|
||
|
|
DeleteCriticalSection( &csReply );
|
||
|
|
}
|
||
|
|
|
||
|
|
void FreeList()
|
||
|
|
{
|
||
|
|
RequestReplyList::iterator i;
|
||
|
|
|
||
|
|
EnterCriticalSection( &csReply );
|
||
|
|
// walk list deleting entries
|
||
|
|
i = replyList.begin();
|
||
|
|
while ( i != replyList.end() )
|
||
|
|
delete *i++;
|
||
|
|
|
||
|
|
replyList.clear();
|
||
|
|
LeaveCriticalSection( &csReply );
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
void remove(CAsyncRequestReply *a)
|
||
|
|
{
|
||
|
|
EnterCriticalSection( &csReply );
|
||
|
|
replyList.remove(a);
|
||
|
|
LeaveCriticalSection( &csReply );
|
||
|
|
}
|
||
|
|
|
||
|
|
CAsyncRequestReply *addRequest(DWORD id)
|
||
|
|
{
|
||
|
|
CAsyncRequestReply *pReply;
|
||
|
|
|
||
|
|
EnterCriticalSection( &csReply );
|
||
|
|
|
||
|
|
// Check list to see if we're already on the list ( i.e. the response LINE_REPLY got here before us)
|
||
|
|
pReply = find(id);
|
||
|
|
if (pReply == NULL || !pReply->IsReply())
|
||
|
|
{
|
||
|
|
// No so we got here before the reply, create a new request entry on the list
|
||
|
|
pReply = new CAsyncRequestReply(id, FALSE, 0);
|
||
|
|
|
||
|
|
if (NULL == pReply)
|
||
|
|
{
|
||
|
|
LOG((TL_ERROR, "Could not alloc for CAsyncRequestReply"));
|
||
|
|
}
|
||
|
|
else if( pReply->getResult() == E_OUTOFMEMORY )
|
||
|
|
{
|
||
|
|
delete pReply;
|
||
|
|
pReply = NULL;
|
||
|
|
LOG((TL_ERROR, "addRequest - Create Semaphore failed"));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
try
|
||
|
|
{
|
||
|
|
replyList.push_back(pReply);
|
||
|
|
}
|
||
|
|
catch(...)
|
||
|
|
{
|
||
|
|
delete pReply;
|
||
|
|
pReply = NULL;
|
||
|
|
LOG((TL_ERROR, "addRequest- failed - because of alloc failure"));
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Else, the reply comes before me, remove it from the list
|
||
|
|
else
|
||
|
|
{
|
||
|
|
replyList.remove (pReply);
|
||
|
|
}
|
||
|
|
|
||
|
|
LeaveCriticalSection( &csReply );
|
||
|
|
return pReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
CAsyncRequestReply *addReply(DWORD id, HRESULT hr)
|
||
|
|
{
|
||
|
|
CAsyncRequestReply *pReply;
|
||
|
|
|
||
|
|
EnterCriticalSection( &csReply );
|
||
|
|
|
||
|
|
// Check list to see if we have a matching entry
|
||
|
|
pReply = find(id);
|
||
|
|
if (pReply == NULL || pReply->IsReply())
|
||
|
|
{
|
||
|
|
// No so we got here before the request returned, create a new entry on the list
|
||
|
|
pReply = new CAsyncRequestReply(id, TRUE, hr);
|
||
|
|
if (NULL == pReply)
|
||
|
|
{
|
||
|
|
LOG((TL_ERROR, "Could not alloc for CAsyncRequestReply"));
|
||
|
|
}
|
||
|
|
else if( pReply->getResult() == E_OUTOFMEMORY )
|
||
|
|
{
|
||
|
|
delete pReply;
|
||
|
|
pReply = NULL;
|
||
|
|
LOG((TL_ERROR, "addReply - Create Semaphore failed"));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
try
|
||
|
|
{
|
||
|
|
replyList.push_back(pReply);
|
||
|
|
}
|
||
|
|
catch(...)
|
||
|
|
{
|
||
|
|
delete pReply;
|
||
|
|
pReply = NULL;
|
||
|
|
LOG((TL_ERROR, "addReply- failed - because of alloc failure"));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Use the existing entry, set its return code & signal to the waiting request code
|
||
|
|
pReply->setResult(hr);
|
||
|
|
replyList.remove (pReply);
|
||
|
|
}
|
||
|
|
|
||
|
|
LeaveCriticalSection( &csReply );
|
||
|
|
return pReply;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Class CRetryQueue
|
||
|
|
// Maintains queue of Async messages for retry.
|
||
|
|
// Typically these relate to calls not yet entered in the call hash-
|
||
|
|
// table, such that findCallObject failed. These are reprocessed
|
||
|
|
// once the call is entered & the ghAsyncRetryQueueEvent event is
|
||
|
|
// signalled.
|
||
|
|
//
|
||
|
|
// Added criticalsection - thread safe now
|
||
|
|
//
|
||
|
|
////////////////////////////////////////////////////////////////////
|
||
|
|
class CRetryQueue
|
||
|
|
{
|
||
|
|
typedef struct _tagRetryQueueEntry
|
||
|
|
{
|
||
|
|
DWORD dwRetryCount;
|
||
|
|
PASYNCEVENTMSG pMessage;
|
||
|
|
} RETRY_QUEUE_ENTRY, *PRETRY_QUEUE_ENTRY;
|
||
|
|
typedef list<RETRY_QUEUE_ENTRY *> RetryQueueListType;
|
||
|
|
|
||
|
|
#define MAX_REQUEUE_TRIES 3
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
RetryQueueListType m_RetryQueueList;
|
||
|
|
CRITICAL_SECTION m_cs;
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// is the queue open for new entries?
|
||
|
|
//
|
||
|
|
|
||
|
|
BOOL m_bAcceptNewEntries;
|
||
|
|
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
//
|
||
|
|
// requeue the entry that failed processing. don't do this if the queue is
|
||
|
|
// closed.
|
||
|
|
//
|
||
|
|
|
||
|
|
void RequeueEvent(PRETRY_QUEUE_ENTRY pQueueEntry);
|
||
|
|
|
||
|
|
|
||
|
|
public:
|
||
|
|
DECLARE_TRACELOG_CLASS(CRetryQueue)
|
||
|
|
|
||
|
|
CRetryQueue()
|
||
|
|
:m_bAcceptNewEntries(FALSE)
|
||
|
|
{
|
||
|
|
InitializeCriticalSection( &m_cs );
|
||
|
|
}
|
||
|
|
|
||
|
|
~CRetryQueue();
|
||
|
|
|
||
|
|
void Lock(){ EnterCriticalSection( &m_cs ); }
|
||
|
|
void Unlock(){ LeaveCriticalSection( &m_cs ); }
|
||
|
|
|
||
|
|
BOOL QueueEvent(PASYNCEVENTMSG pEvent);
|
||
|
|
BOOL DequeueEvent(PRETRY_QUEUE_ENTRY * ppEvent);
|
||
|
|
void ProcessQueue();
|
||
|
|
void RemoveNewCallHub(DWORD);
|
||
|
|
inline BOOL ItemsInQueue()
|
||
|
|
{
|
||
|
|
BOOL bReturn;
|
||
|
|
|
||
|
|
Lock();
|
||
|
|
bReturn = !m_RetryQueueList.empty();
|
||
|
|
Unlock();
|
||
|
|
|
||
|
|
return bReturn;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// after this function returns, the queue will accept new entries
|
||
|
|
//
|
||
|
|
|
||
|
|
void OpenForNewEntries();
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// new entries will be denied after this function returns
|
||
|
|
//
|
||
|
|
|
||
|
|
void CloseForNewEntries();
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
#define MAXCACHEENTRIES 5
|
||
|
|
#define BUFFERTYPE_ADDRCAP 1
|
||
|
|
#define BUFFERTYPE_LINEDEVCAP 2
|
||
|
|
#define BUFFERTYPE_PHONECAP 3
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
UINT_PTR pObject;
|
||
|
|
LPVOID pBuffer;
|
||
|
|
|
||
|
|
} CACHEENTRY;
|
||
|
|
|
||
|
|
|
||
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
|
//
|
||
|
|
// CStructCache
|
||
|
|
//
|
||
|
|
// A simple class to cache TAPI structures in tapi3.dll
|
||
|
|
//
|
||
|
|
// This implementation has an array of CACHEENTRY structures. Each
|
||
|
|
// CACHEENTRY structure has 2 member:
|
||
|
|
// pObject - the object that currently owns the buffer
|
||
|
|
// pBuffer - the buffer
|
||
|
|
//
|
||
|
|
// The array is a fixed size, which is set when the class is initialized
|
||
|
|
// The memory for the buffers is allocated during initialization as
|
||
|
|
// well. It is possible that a buffer gets realloced (replaced)
|
||
|
|
// at some time.
|
||
|
|
//
|
||
|
|
// This implementation assumes that the object that owns the buffer
|
||
|
|
// uses it's critical sections correctly. That is, it is locked when
|
||
|
|
// SetXxxBuffer is called, and it is locked when getting and using
|
||
|
|
// a buffer If not, the buffer can disapper from the object at any time.
|
||
|
|
//
|
||
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
|
class CStructCache
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
CRITICAL_SECTION m_cs;
|
||
|
|
DWORD m_dwType;
|
||
|
|
DWORD m_dwMaxEntries;
|
||
|
|
DWORD m_dwUsedEntries;
|
||
|
|
CACHEENTRY m_aEntries[MAXCACHEENTRIES];
|
||
|
|
|
||
|
|
public:
|
||
|
|
DECLARE_TRACELOG_CLASS(CStructCache)
|
||
|
|
|
||
|
|
CStructCache()
|
||
|
|
{
|
||
|
|
int iCount;
|
||
|
|
|
||
|
|
InitializeCriticalSection( &m_cs );
|
||
|
|
|
||
|
|
for( iCount=0; iCount<MAXCACHEENTRIES; iCount++)
|
||
|
|
{
|
||
|
|
m_aEntries[iCount].pObject = NULL;
|
||
|
|
m_aEntries[iCount].pBuffer = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dwType = 0;
|
||
|
|
m_dwMaxEntries = 0;
|
||
|
|
m_dwUsedEntries = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
~CStructCache()
|
||
|
|
{
|
||
|
|
DeleteCriticalSection( &m_cs );
|
||
|
|
}
|
||
|
|
|
||
|
|
void Lock()
|
||
|
|
{
|
||
|
|
EnterCriticalSection( &m_cs );
|
||
|
|
}
|
||
|
|
void Unlock()
|
||
|
|
{
|
||
|
|
LeaveCriticalSection( &m_cs );
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT Initialize( DWORD dwMaxEntries, DWORD dwSize, DWORD dwType );
|
||
|
|
HRESULT Shutdown();
|
||
|
|
HRESULT GetBuffer( UINT_PTR pNewObject, LPVOID * ppReturnStruct );
|
||
|
|
HRESULT SetBuffer( UINT_PTR pObject, LPVOID pNewStruct );
|
||
|
|
HRESULT InvalidateBuffer( UINT_PTR pObject );
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
|
//
|
||
|
|
// CArray - based on from CSimpleArray from atl
|
||
|
|
//
|
||
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
|
template <class T>
|
||
|
|
class CTObjectArray
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
|
||
|
|
T * m_aT;
|
||
|
|
int m_nSize;
|
||
|
|
int m_nUsed;
|
||
|
|
|
||
|
|
public:
|
||
|
|
DECLARE_TRACELOG_CLASS(CTObjectArray)
|
||
|
|
CTObjectArray() : m_aT(NULL), m_nSize(0), m_nUsed(0){}
|
||
|
|
|
||
|
|
~CTObjectArray()
|
||
|
|
{}
|
||
|
|
|
||
|
|
int GetSize() const
|
||
|
|
{
|
||
|
|
return m_nUsed;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL Add(T& t)
|
||
|
|
{
|
||
|
|
if(m_nSize == m_nUsed)
|
||
|
|
{
|
||
|
|
T * aT;
|
||
|
|
int nNewSize;
|
||
|
|
|
||
|
|
nNewSize = (m_nSize == 0) ? 1 : (m_nSize * 2);
|
||
|
|
|
||
|
|
aT = (T*) ClientAlloc (nNewSize * sizeof(T));
|
||
|
|
|
||
|
|
if(aT == NULL)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
CopyMemory(
|
||
|
|
aT,
|
||
|
|
m_aT,
|
||
|
|
m_nUsed * sizeof(T)
|
||
|
|
);
|
||
|
|
|
||
|
|
ClientFree( m_aT );
|
||
|
|
|
||
|
|
m_aT = aT;
|
||
|
|
|
||
|
|
m_nSize = nNewSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_aT[m_nUsed] = t;
|
||
|
|
|
||
|
|
t->AddRef();
|
||
|
|
|
||
|
|
m_nUsed++;
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL Remove(T& t)
|
||
|
|
{
|
||
|
|
int nIndex = Find(t);
|
||
|
|
|
||
|
|
if(nIndex == -1)
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
return RemoveAt(nIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL RemoveAt(int nIndex)
|
||
|
|
{
|
||
|
|
m_aT[nIndex]->Release();
|
||
|
|
|
||
|
|
if(nIndex != (m_nUsed - 1))
|
||
|
|
{
|
||
|
|
MoveMemory(
|
||
|
|
(void*)&m_aT[nIndex],
|
||
|
|
(void*)&m_aT[nIndex + 1],
|
||
|
|
(m_nUsed - (nIndex + 1)) * sizeof(T)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
m_nUsed--;
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
void Shutdown()
|
||
|
|
{
|
||
|
|
if( NULL != m_aT )
|
||
|
|
{
|
||
|
|
int index;
|
||
|
|
|
||
|
|
for (index = 0; index < m_nUsed; index++)
|
||
|
|
{
|
||
|
|
m_aT[index]->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
ClientFree(m_aT);
|
||
|
|
|
||
|
|
m_aT = NULL;
|
||
|
|
m_nUsed = 0;
|
||
|
|
m_nSize = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
T& operator[] (int nIndex) const
|
||
|
|
{
|
||
|
|
_ASSERTE(nIndex >= 0 && nIndex < m_nUsed);
|
||
|
|
return m_aT[nIndex];
|
||
|
|
}
|
||
|
|
|
||
|
|
int Find(T& t) const
|
||
|
|
{
|
||
|
|
for(int i = 0; i < m_nUsed; i++)
|
||
|
|
{
|
||
|
|
if(m_aT[i] == t)
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
return -1; // not found
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
|
//
|
||
|
|
// CArray - based on from CSimpleArray from atl
|
||
|
|
//
|
||
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
|
template <class T>
|
||
|
|
class CTArray
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
|
||
|
|
T * m_aT;
|
||
|
|
int m_nSize;
|
||
|
|
int m_nUsed;
|
||
|
|
|
||
|
|
public:
|
||
|
|
DECLARE_TRACELOG_CLASS(CTArray)
|
||
|
|
|
||
|
|
CTArray() : m_aT(NULL), m_nSize(0), m_nUsed(0){}
|
||
|
|
|
||
|
|
~CTArray()
|
||
|
|
{}
|
||
|
|
|
||
|
|
int GetSize() const
|
||
|
|
{
|
||
|
|
return m_nUsed;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL Add(T& t)
|
||
|
|
{
|
||
|
|
if(m_nSize == m_nUsed)
|
||
|
|
{
|
||
|
|
T * aT;
|
||
|
|
int nNewSize;
|
||
|
|
|
||
|
|
nNewSize = (m_nSize == 0) ? 1 : (m_nSize * 2);
|
||
|
|
|
||
|
|
aT = (T*) ClientAlloc (nNewSize * sizeof(T));
|
||
|
|
|
||
|
|
if(aT == NULL)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
CopyMemory(
|
||
|
|
aT,
|
||
|
|
m_aT,
|
||
|
|
m_nUsed * sizeof(T)
|
||
|
|
);
|
||
|
|
|
||
|
|
ClientFree( m_aT );
|
||
|
|
|
||
|
|
m_aT = aT;
|
||
|
|
|
||
|
|
m_nSize = nNewSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_aT[m_nUsed] = t;
|
||
|
|
|
||
|
|
m_nUsed++;
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL Remove(T& t)
|
||
|
|
{
|
||
|
|
int nIndex = Find(t);
|
||
|
|
|
||
|
|
if(nIndex == -1)
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
return RemoveAt(nIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL RemoveAt(int nIndex)
|
||
|
|
{
|
||
|
|
if(nIndex != (m_nUsed - 1))
|
||
|
|
{
|
||
|
|
MoveMemory(
|
||
|
|
(void*)&m_aT[nIndex],
|
||
|
|
(void*)&m_aT[nIndex + 1],
|
||
|
|
(m_nUsed - (nIndex + 1)) * sizeof(T)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
m_nUsed--;
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
void Shutdown()
|
||
|
|
{
|
||
|
|
if( NULL != m_aT )
|
||
|
|
{
|
||
|
|
int index;
|
||
|
|
|
||
|
|
ClientFree(m_aT);
|
||
|
|
|
||
|
|
m_aT = NULL;
|
||
|
|
m_nUsed = 0;
|
||
|
|
m_nSize = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
T& operator[] (int nIndex) const
|
||
|
|
{
|
||
|
|
_ASSERTE(nIndex >= 0 && nIndex < m_nUsed);
|
||
|
|
return m_aT[nIndex];
|
||
|
|
}
|
||
|
|
|
||
|
|
int Find(T& t) const
|
||
|
|
{
|
||
|
|
for(int i = 0; i < m_nUsed; i++)
|
||
|
|
{
|
||
|
|
if(m_aT[i] == t)
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
return -1; // not found
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#endif // __UTILS_H__
|
||
|
|
|
||
|
|
|
||
|
|
|