1615 lines
35 KiB
C++
1615 lines
35 KiB
C++
//***************************************************************************
|
|
|
|
//
|
|
|
|
// PROVLOG.CPP
|
|
|
|
//
|
|
|
|
// Module: OLE MS PROVIDER FRAMEWORK
|
|
|
|
//
|
|
|
|
// Copyright (c) 1996-2001 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include <precomp.h>
|
|
#include <provimex.h>
|
|
#include <provexpt.h>
|
|
#include <provstd.h>
|
|
#include <provmt.h>
|
|
#include <string.h>
|
|
#include <provlog.h>
|
|
#include <provevt.h>
|
|
#include <provthrd.h>
|
|
#include <Allocator.h>
|
|
#include <Algorithms.h>
|
|
#include <RedBlackTree.h>
|
|
|
|
#define LOG_KEY _T("Software\\Microsoft\\WBEM\\PROVIDERS\\Logging")
|
|
#define LOG_KEY_SLASH _T("Software\\Microsoft\\WBEM\\PROVIDERS\\Logging\\")
|
|
#define LOGGING_ON _T("Logging")
|
|
#define BACKSLASH_STRING _T("\\")
|
|
#define DEFAULT_FILE_EXT _T(".log")
|
|
#define LOGGING_DIR_VALUE _T("Logging Directory")
|
|
#define LOGGING_DIR_KEY _T("Software\\Microsoft\\WBEM\\CIMOM")
|
|
#define DEFAULT_PATH _T("C:\\")
|
|
#define DEFAULT_FILE_SIZE 0x0FFFF
|
|
#define MIN_FILE_SIZE 1024
|
|
#define MAX_MESSAGE_SIZE 1024
|
|
#define HALF_MAX_MESSAGE_SIZE 512
|
|
|
|
#define LOG_FILE_NAME _T("File")
|
|
#define LOG_LEVEL_NAME _T("Level")
|
|
#define LOG_FILE_SIZE _T("MaxFileSize")
|
|
#define LOG_TYPE_NAME _T("Type")
|
|
#define LOG_TYPE_FILE_STRING _T("File")
|
|
#define LOG_TYPE_DEBUG_STRING _T("Debugger")
|
|
|
|
long ProvDebugLog :: s_ReferenceCount = 0 ;
|
|
CRITICAL_SECTION ProvDebugLog :: s_CriticalSection ;
|
|
|
|
typedef WmiRedBlackTree <ProvDebugLog *,ProvDebugLog *> LogContainer ;
|
|
typedef WmiRedBlackTree <ProvDebugLog *,ProvDebugLog *> :: Iterator LogContainerIterator ;
|
|
|
|
LogContainer g_LogContainer ( g_Allocator ) ;
|
|
|
|
CRITICAL_SECTION g_ProvDebugLogMapCriticalSection ;
|
|
|
|
class ProvDebugTaskObject : public ProvTaskObject
|
|
{
|
|
private:
|
|
|
|
HKEY m_LogKey ;
|
|
|
|
protected:
|
|
public:
|
|
|
|
ProvDebugTaskObject () ;
|
|
~ProvDebugTaskObject () ;
|
|
|
|
void Process () ;
|
|
|
|
void SetRegistryNotification () ;
|
|
} ;
|
|
|
|
ProvDebugTaskObject :: ProvDebugTaskObject () : m_LogKey ( NULL )
|
|
{
|
|
}
|
|
|
|
ProvDebugTaskObject :: ~ProvDebugTaskObject ()
|
|
{
|
|
if ( m_LogKey )
|
|
RegCloseKey ( m_LogKey ) ;
|
|
}
|
|
|
|
void ProvDebugTaskObject :: Process ()
|
|
{
|
|
ProvDebugLog *t_ProvDebugLog = NULL ;
|
|
|
|
EnterCriticalSection ( &g_ProvDebugLogMapCriticalSection ) ;
|
|
|
|
LogContainerIterator t_Iterator = g_LogContainer.Begin () ;
|
|
while ( ! t_Iterator.Null () )
|
|
{
|
|
t_Iterator.GetElement ()->LoadRegistry () ;
|
|
t_Iterator.GetElement ()->SetRegistry () ;
|
|
|
|
t_Iterator.Increment () ;
|
|
}
|
|
|
|
LeaveCriticalSection ( &g_ProvDebugLogMapCriticalSection ) ;
|
|
SetRegistryNotification () ;
|
|
|
|
Complete () ;
|
|
}
|
|
|
|
typedef LONG ( *FuncRegNotifyChangeKeyValue ) (
|
|
|
|
HKEY hKey,
|
|
BOOL bWatchSubtree,
|
|
DWORD dwNotifyFilter,
|
|
HANDLE hEvent,
|
|
BOOL fAsynchronous
|
|
) ;
|
|
|
|
void ProvDebugTaskObject :: SetRegistryNotification ()
|
|
{
|
|
if ( m_LogKey )
|
|
RegCloseKey ( m_LogKey ) ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
LOG_KEY,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&m_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
OSVERSIONINFO t_OS;
|
|
t_OS.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
if ( ! GetVersionEx ( & t_OS ) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
if ( ! ( t_OS.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && t_OS.dwMinorVersion == 0 ) )
|
|
{
|
|
HINSTANCE t_Library = LoadLibrary( _TEXT("ADVAPI32.DLL"));
|
|
if ( t_Library )
|
|
{
|
|
FuncRegNotifyChangeKeyValue t_RegNotifyChangeKeyValue = ( FuncRegNotifyChangeKeyValue ) GetProcAddress ( t_Library , "RegNotifyChangeKeyValue" ) ;
|
|
|
|
t_Status = t_RegNotifyChangeKeyValue (
|
|
|
|
m_LogKey ,
|
|
TRUE ,
|
|
REG_NOTIFY_CHANGE_LAST_SET ,
|
|
GetHandle () ,
|
|
TRUE
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
}
|
|
|
|
FreeLibrary ( t_Library ) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ProvDebugThreadObject : public ProvThreadObject
|
|
{
|
|
private:
|
|
|
|
ProvDebugTaskObject *m_ProvDebugTaskObject ;
|
|
|
|
protected:
|
|
|
|
void Uninitialise () { delete this ; }
|
|
|
|
public:
|
|
|
|
ProvDebugThreadObject ( const TCHAR *a_Thread ) ;
|
|
~ProvDebugThreadObject () ;
|
|
void ScheduleDebugTask () ;
|
|
|
|
ProvDebugTaskObject *GetTaskObject () ;
|
|
} ;
|
|
|
|
ProvDebugThreadObject *g_ProvDebugLogThread = NULL ;
|
|
|
|
ProvDebugLog *ProvDebugLog :: s_ProvDebugLog = NULL ;
|
|
BOOL ProvDebugLog :: s_Initialised = FALSE ;
|
|
|
|
ProvDebugThreadObject :: ProvDebugThreadObject ( const TCHAR *a_Thread )
|
|
: ProvThreadObject ( a_Thread ) ,
|
|
m_ProvDebugTaskObject ( NULL )
|
|
{
|
|
}
|
|
|
|
ProvDebugThreadObject :: ~ProvDebugThreadObject ()
|
|
{
|
|
delete ProvDebugLog :: s_ProvDebugLog ;
|
|
ProvDebugLog :: s_ProvDebugLog = NULL ;
|
|
|
|
if (m_ProvDebugTaskObject)
|
|
{
|
|
ReapTask ( *m_ProvDebugTaskObject ) ;
|
|
delete m_ProvDebugTaskObject ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugThreadObject :: ScheduleDebugTask ()
|
|
{
|
|
m_ProvDebugTaskObject = new ProvDebugTaskObject ;
|
|
ProvDebugLog :: s_ProvDebugLog = new ProvDebugLog ( _T("WBEMSNMP") ) ;
|
|
ScheduleTask ( *m_ProvDebugTaskObject ) ;
|
|
}
|
|
|
|
ProvDebugTaskObject *ProvDebugThreadObject :: GetTaskObject ()
|
|
{
|
|
return m_ProvDebugTaskObject ;
|
|
}
|
|
|
|
ProvDebugLog :: ProvDebugLog (
|
|
|
|
const TCHAR *a_DebugComponent
|
|
|
|
) : m_Logging ( FALSE ) ,
|
|
m_DebugLevel ( 0 ) ,
|
|
m_DebugFileSize ( DEFAULT_FILE_SIZE ),
|
|
m_DebugContext ( ProvDebugContext :: FILE ) ,
|
|
m_DebugFile ( NULL ) ,
|
|
m_DebugFileUnexpandedName ( NULL) ,
|
|
m_DebugFileHandle ( INVALID_HANDLE_VALUE ) ,
|
|
m_DebugComponent ( NULL )
|
|
{
|
|
EnterCriticalSection ( &g_ProvDebugLogMapCriticalSection ) ;
|
|
InitializeCriticalSection(&m_CriticalSection);
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
LogContainerIterator t_Iterator ;
|
|
WmiStatusCode t_StatusCode = g_LogContainer.Insert ( this , this , t_Iterator ) ;
|
|
|
|
if ( a_DebugComponent )
|
|
{
|
|
m_DebugComponent = new TCHAR[_tcslen(a_DebugComponent) + 1];
|
|
// new would have thrown if it failed... hence no check
|
|
_tcscpy(m_DebugComponent, a_DebugComponent);
|
|
}
|
|
|
|
LoadRegistry () ;
|
|
SetRegistry () ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
LeaveCriticalSection ( &g_ProvDebugLogMapCriticalSection ) ;
|
|
}
|
|
|
|
ProvDebugLog :: ~ProvDebugLog ()
|
|
{
|
|
EnterCriticalSection ( &g_ProvDebugLogMapCriticalSection ) ;
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
WmiStatusCode t_StatusCode = g_LogContainer.Delete ( this ) ;
|
|
|
|
CloseOutput () ;
|
|
|
|
if (m_DebugComponent)
|
|
{
|
|
delete m_DebugComponent ;
|
|
m_DebugComponent = NULL ;
|
|
}
|
|
|
|
if (m_DebugFile)
|
|
{
|
|
delete m_DebugFile ;
|
|
m_DebugFile = NULL ;
|
|
}
|
|
|
|
if (m_DebugFileUnexpandedName)
|
|
{
|
|
delete m_DebugFileUnexpandedName ;
|
|
m_DebugFileUnexpandedName = NULL ;
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
DeleteCriticalSection(&m_CriticalSection);
|
|
LeaveCriticalSection ( &g_ProvDebugLogMapCriticalSection ) ;
|
|
}
|
|
|
|
void ProvDebugLog :: SetDefaultFile ( )
|
|
{
|
|
HKEY hkey;
|
|
|
|
LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
LOGGING_DIR_KEY, 0, KEY_READ, &hkey);
|
|
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
TCHAR t_path [MAX_PATH + 1];
|
|
DWORD t_ValueType = REG_SZ;
|
|
DWORD t_ValueLength = MAX_PATH + 1;
|
|
|
|
result = RegQueryValueEx(
|
|
hkey ,
|
|
LOGGING_DIR_VALUE ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) t_path ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ((result == ERROR_SUCCESS) && (t_ValueType == REG_SZ || t_ValueType == REG_EXPAND_SZ))
|
|
{
|
|
_tcscat(t_path, BACKSLASH_STRING);
|
|
_tcscat(t_path, m_DebugComponent);
|
|
_tcscat(t_path, DEFAULT_FILE_EXT);
|
|
SetFile (t_path);
|
|
SetExpandedFile(t_path);
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
if (m_DebugFileUnexpandedName == NULL)
|
|
{
|
|
TCHAR path[MAX_PATH + 1];
|
|
_stprintf(path, _T("%s%s%s"), DEFAULT_PATH, m_DebugComponent, DEFAULT_FILE_EXT);
|
|
SetFile (path);
|
|
SetExpandedFile(path);
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SwapFileOver()
|
|
{
|
|
Flush();
|
|
CloseOutput();
|
|
|
|
//prepend a character to the log file name
|
|
TCHAR* buff = new TCHAR[_tcslen(m_DebugFile) + 2];
|
|
|
|
//find the last occurrence of \ for dir
|
|
TCHAR* tmp = _tcsrchr(m_DebugFile, '\\');
|
|
|
|
if (tmp != NULL)
|
|
{
|
|
tmp++;
|
|
_tcsncpy(buff, m_DebugFile, _tcslen(m_DebugFile) - _tcslen(tmp));
|
|
buff[_tcslen(m_DebugFile) - _tcslen(tmp)] = _T('\0');
|
|
_tcscat(buff, _T("~"));
|
|
_tcscat(buff, tmp);
|
|
}
|
|
else
|
|
{
|
|
_tcscpy(buff, _T("~"));
|
|
_tcscat(buff, m_DebugFile);
|
|
}
|
|
|
|
BOOL bOpen = MoveFileEx(m_DebugFile, buff, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
|
|
|
|
//move the file and reopen...
|
|
if (!bOpen)
|
|
{
|
|
#if 0
|
|
DWORD x = GetLastError();
|
|
wchar_t* buff2;
|
|
|
|
if (0 == FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL, x, 0, (LPWSTR) &buff2, 80, NULL))
|
|
{
|
|
DWORD dwErr = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
LocalFree(buff2);
|
|
}
|
|
#endif
|
|
//try deleting the file and then moving it
|
|
DeleteFile(buff);
|
|
MoveFileEx(m_DebugFile, buff, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
|
|
bOpen = DeleteFile(m_DebugFile);
|
|
}
|
|
|
|
if (bOpen)
|
|
{
|
|
//open file only if move file worked...
|
|
OpenOutput();
|
|
}
|
|
|
|
delete [] buff;
|
|
}
|
|
|
|
void ProvDebugLog :: WriteOutput ( const TCHAR *a_OutputDebugString )
|
|
{
|
|
switch ( m_DebugContext )
|
|
{
|
|
case FILE:
|
|
{
|
|
if ( m_DebugFileHandle == INVALID_HANDLE_VALUE )
|
|
{
|
|
CloseOutput();
|
|
OpenOutput();
|
|
}
|
|
|
|
if ( m_DebugFileHandle != INVALID_HANDLE_VALUE )
|
|
{
|
|
DWORD dwToWrite = sizeof ( TCHAR ) * ( _tcslen ( a_OutputDebugString ) );
|
|
LPCVOID thisWrite = ( LPCVOID ) a_OutputDebugString;
|
|
BOOL t_Status = TRUE;
|
|
|
|
while ((dwToWrite != 0) && (t_Status))
|
|
{
|
|
DWORD dwSize;
|
|
dwSize = SetFilePointer ( m_DebugFileHandle , 0 , NULL , FILE_END );
|
|
|
|
//if the file is too big swap it...
|
|
#ifdef _UNICODE
|
|
//only whole (2byte) characters written to file
|
|
if ((m_DebugFileSize > 0) && (dwSize >= (m_DebugFileSize - 1)))
|
|
#else
|
|
if ((m_DebugFileSize > 0) && (dwSize >= m_DebugFileSize))
|
|
#endif
|
|
{
|
|
SwapFileOver();
|
|
|
|
if ( m_DebugFileHandle == INVALID_HANDLE_VALUE )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (m_DebugFileSize > 0)
|
|
{
|
|
dwSize = SetFilePointer ( m_DebugFileHandle , 0 , NULL , FILE_END );
|
|
}
|
|
}
|
|
|
|
if (dwSize == 0xFFFFFFFF)
|
|
{
|
|
break;
|
|
}
|
|
|
|
DWORD t_BytesWritten = 0 ;
|
|
DWORD dwThisWrite;
|
|
|
|
if ((m_DebugFileSize > 0) && (dwToWrite + dwSize > m_DebugFileSize))
|
|
{
|
|
dwThisWrite = m_DebugFileSize - dwSize;
|
|
#ifdef _UNICODE
|
|
if ((dwThisWrite > 1) && (dwThisWrite%2))
|
|
{
|
|
dwThisWrite--;
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
dwThisWrite = dwToWrite;
|
|
}
|
|
|
|
LockFile(m_DebugFileHandle, dwSize, 0, dwSize + dwThisWrite, 0);
|
|
t_Status = WriteFile (
|
|
|
|
m_DebugFileHandle ,
|
|
thisWrite ,
|
|
dwThisWrite ,
|
|
& t_BytesWritten ,
|
|
NULL
|
|
) ;
|
|
UnlockFile(m_DebugFileHandle, dwSize, 0, dwSize + dwThisWrite, 0);
|
|
|
|
//get ready for next write...
|
|
dwToWrite -= t_BytesWritten;
|
|
thisWrite = (LPCVOID)((UCHAR*)thisWrite + t_BytesWritten);
|
|
}
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case DEBUG:
|
|
{
|
|
OutputDebugString ( a_OutputDebugString ) ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
}
|
|
break ;
|
|
}
|
|
|
|
}
|
|
|
|
void ProvDebugLog :: WriteOutputW ( const WCHAR *a_OutputDebugString )
|
|
{
|
|
|
|
#ifdef _UNICODE
|
|
WriteOutput(a_OutputDebugString);
|
|
#else
|
|
// Convert to MBCS, then call WriteOutput()
|
|
char t_OutputString [MAX_MESSAGE_SIZE];
|
|
WideCharToMultiByte(CP_ACP, 0, a_OutputDebugString, -1, t_OutputString, MAX_MESSAGE_SIZE, NULL, NULL);
|
|
WriteOutput ( t_OutputString ) ;
|
|
#endif
|
|
|
|
}
|
|
|
|
void ProvDebugLog :: WriteOutputA ( const char *a_OutputDebugString )
|
|
{
|
|
|
|
#ifdef _UNICODE
|
|
// Convert to WCS, then call WriteOutput()
|
|
WCHAR t_OutputString [MAX_MESSAGE_SIZE];
|
|
MultiByteToWideChar( CP_ACP, 0, a_OutputDebugString, -1, t_OutputString, MAX_MESSAGE_SIZE);
|
|
WriteOutput ( t_OutputString ) ;
|
|
#else
|
|
WriteOutput(a_OutputDebugString);
|
|
#endif
|
|
}
|
|
|
|
void ProvDebugLog :: OpenFileForOutput ()
|
|
{
|
|
if ( m_DebugFile )
|
|
{
|
|
m_DebugFileHandle = CreateFile (
|
|
|
|
m_DebugFile ,
|
|
GENERIC_WRITE ,
|
|
#ifdef _UNICODE
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
#else
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
#endif
|
|
NULL ,
|
|
OPEN_EXISTING ,
|
|
FILE_ATTRIBUTE_NORMAL ,
|
|
NULL
|
|
) ;
|
|
|
|
if ( m_DebugFileHandle == INVALID_HANDLE_VALUE )
|
|
{
|
|
m_DebugFileHandle = CreateFile (
|
|
|
|
m_DebugFile ,
|
|
GENERIC_WRITE ,
|
|
#ifdef _UNICODE
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
#else
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
#endif
|
|
NULL ,
|
|
OPEN_ALWAYS ,
|
|
FILE_ATTRIBUTE_NORMAL ,
|
|
NULL
|
|
) ;
|
|
|
|
#ifdef _UNICODE
|
|
|
|
if ( m_DebugFileHandle != INVALID_HANDLE_VALUE )
|
|
{
|
|
UCHAR t_UnicodeBytes [ 2 ] ;
|
|
t_UnicodeBytes [ 0 ] = 0xFF ;
|
|
t_UnicodeBytes [ 1 ] = 0xFE ;
|
|
|
|
DWORD t_BytesWritten = 0 ;
|
|
|
|
LockFile(m_DebugFileHandle, 0, 0, 2, 0);
|
|
|
|
WriteFile (
|
|
|
|
m_DebugFileHandle ,
|
|
( LPCVOID ) & t_UnicodeBytes ,
|
|
sizeof ( t_UnicodeBytes ) ,
|
|
& t_BytesWritten ,
|
|
NULL
|
|
) ;
|
|
|
|
UnlockFile(m_DebugFileHandle, 0, 0, 2, 0);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: OpenOutput ()
|
|
{
|
|
switch ( m_DebugContext )
|
|
{
|
|
case FILE:
|
|
{
|
|
OpenFileForOutput () ;
|
|
}
|
|
break ;
|
|
|
|
case DEBUG:
|
|
default:
|
|
{
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: FlushOutput ()
|
|
{
|
|
switch ( m_DebugContext )
|
|
{
|
|
case FILE:
|
|
{
|
|
if ( m_DebugFileHandle != INVALID_HANDLE_VALUE )
|
|
{
|
|
FlushFileBuffers ( m_DebugFileHandle ) ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case DEBUG:
|
|
default:
|
|
{
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: CloseOutput ()
|
|
{
|
|
switch ( m_DebugContext )
|
|
{
|
|
case FILE:
|
|
{
|
|
if ( m_DebugFileHandle != INVALID_HANDLE_VALUE )
|
|
{
|
|
CloseHandle ( m_DebugFileHandle ) ;
|
|
m_DebugFileHandle = INVALID_HANDLE_VALUE ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case DEBUG:
|
|
default:
|
|
{
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
|
|
void ProvDebugLog :: Write ( const TCHAR *a_DebugFormatString , ... )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
TCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
va_list t_VarArgList ;
|
|
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsntprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( TCHAR ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutput ( t_OutputDebugString ) ;
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: WriteW ( const WCHAR *a_DebugFormatString , ... )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
WCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
va_list t_VarArgList ;
|
|
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsnwprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( WCHAR ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutputW ( t_OutputDebugString ) ;
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: WriteA ( const char *a_DebugFormatString , ... )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
char t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
va_list t_VarArgList ;
|
|
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsnprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( char ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutputA ( t_OutputDebugString ) ;
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: WriteFileAndLine ( const TCHAR *a_File , const ULONG a_Line , const TCHAR *a_DebugFormatString , ... )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
#ifdef BUILD_WITH_FILE_AND_LINE
|
|
|
|
TCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
|
|
_sntprintf ( t_OutputDebugString , HALF_MAX_MESSAGE_SIZE , _TEXT("\r\n(%s):(%lu):") , a_File , a_Line ) ;
|
|
WriteOutput ( t_OutputDebugString ) ;
|
|
|
|
va_list t_VarArgList ;
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsntprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( TCHAR ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutput ( t_OutputDebugString ) ;
|
|
|
|
#else
|
|
|
|
TCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
|
|
_sntprintf ( t_OutputDebugString , HALF_MAX_MESSAGE_SIZE , _TEXT("\r\n") ) ;
|
|
WriteOutput ( t_OutputDebugString ) ;
|
|
|
|
va_list t_VarArgList ;
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsntprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( TCHAR ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutput ( t_OutputDebugString ) ;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: WriteFileAndLineW ( const WCHAR *a_File , const ULONG a_Line , const WCHAR *a_DebugFormatString , ... )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
#ifdef BUILD_WITH_FILE_AND_LINE
|
|
|
|
WCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
|
|
_snwprintf ( t_OutputDebugString , HALF_MAX_MESSAGE_SIZE , L"\r\n(%s):(%lu):" , a_File , a_Line ) ;
|
|
WriteOutputW ( t_OutputDebugString ) ;
|
|
|
|
va_list t_VarArgList ;
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsnwprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( WCHAR ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutputW ( t_OutputDebugString ) ;
|
|
|
|
#else
|
|
|
|
WCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
|
|
_snwprintf ( t_OutputDebugString , HALF_MAX_MESSAGE_SIZE , L"\r\n" ) ;
|
|
WriteOutputW ( t_OutputDebugString ) ;
|
|
|
|
va_list t_VarArgList ;
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsnwprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = (WCHAR) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutputW ( t_OutputDebugString ) ;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: WriteFileAndLineA ( const char *a_File , const ULONG a_Line , const char *a_DebugFormatString , ... )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
#ifdef BUILD_WITH_FILE_AND_LINE
|
|
|
|
char t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
|
|
_snprintf ( t_OutputDebugString , HALF_MAX_MESSAGE_SIZE , "\r\n(%s):(%lu):" , a_File , a_Line ) ;
|
|
WriteOutputA ( t_OutputDebugString ) ;
|
|
|
|
va_list t_VarArgList ;
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsnprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( char ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutputA ( t_OutputDebugString ) ;
|
|
|
|
#else
|
|
|
|
char t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
|
|
_snprintf ( t_OutputDebugString , HALF_MAX_MESSAGE_SIZE , "\r\n" ) ;
|
|
WriteOutputA ( t_OutputDebugString ) ;
|
|
|
|
va_list t_VarArgList ;
|
|
va_start(t_VarArgList,a_DebugFormatString);
|
|
int t_Length = _vsnprintf (t_OutputDebugString , MAX_MESSAGE_SIZE-1 , a_DebugFormatString , t_VarArgList );
|
|
t_OutputDebugString [ t_Length ] = ( char ) 0 ;
|
|
va_end(t_VarArgList);
|
|
|
|
WriteOutputA ( t_OutputDebugString ) ;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
|
|
void ProvDebugLog :: Flush ()
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
FlushOutput () ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: SetLogging ( BOOL a_Logging )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
m_Logging = a_Logging ;
|
|
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: SetLevel ( const DWORD &a_DebugLevel )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
m_DebugLevel = a_DebugLevel ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: SetContext ( const enum ProvDebugContext &a_DebugContext )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
m_DebugContext = a_DebugContext ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
enum ProvDebugLog :: ProvDebugContext ProvDebugLog :: GetContext ()
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
ProvDebugContext t_Context = m_DebugContext ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
|
|
return t_Context ;
|
|
}
|
|
|
|
void ProvDebugLog ::CommitContext ()
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
CloseOutput () ;
|
|
OpenOutput () ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog ::SetFile ( const TCHAR *a_File )
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
if (m_DebugFileUnexpandedName)
|
|
{
|
|
delete m_DebugFileUnexpandedName ;
|
|
m_DebugFileUnexpandedName = NULL ;
|
|
}
|
|
|
|
m_DebugFileUnexpandedName = new TCHAR[_tcslen(a_File) + 1];
|
|
// new would have thrown if it failed... hence no check
|
|
_tcscpy ( m_DebugFileUnexpandedName, a_File ) ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
|
|
void ProvDebugLog::SetExpandedFile(
|
|
const TCHAR *a_RawFileName)
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
DWORD dwNumChars = ::ExpandEnvironmentStrings(
|
|
a_RawFileName,
|
|
NULL,
|
|
0);
|
|
|
|
if(dwNumChars > 0)
|
|
{
|
|
try
|
|
{
|
|
m_DebugFile = new TCHAR[dwNumChars + 1];
|
|
if(m_DebugFile)
|
|
{
|
|
m_DebugFile[dwNumChars] = L'\0';
|
|
|
|
if(!::ExpandEnvironmentStrings(
|
|
a_RawFileName,
|
|
m_DebugFile,
|
|
dwNumChars))
|
|
{
|
|
delete m_DebugFile;
|
|
m_DebugFile = NULL;
|
|
}
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: LoadRegistry()
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
LoadRegistry_Logging () ;
|
|
LoadRegistry_Level () ;
|
|
LoadRegistry_File () ;
|
|
LoadRegistry_Type () ;
|
|
LoadRegistry_FileSize ();
|
|
CommitContext () ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: LoadRegistry_Logging ()
|
|
{
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
LOG_KEY,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
DWORD t_Logging ;
|
|
DWORD t_ValueType = REG_DWORD ;
|
|
DWORD t_ValueLength = sizeof ( DWORD ) ;
|
|
t_Status = RegQueryValueEx (
|
|
|
|
t_LogKey ,
|
|
LOGGING_ON ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) &t_Logging ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
m_Logging = ( t_Logging == 1) ? TRUE : FALSE ;
|
|
}
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: LoadRegistry_FileSize ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
DWORD t_Size ;
|
|
DWORD t_ValueType = REG_DWORD ;
|
|
DWORD t_ValueLength = sizeof ( DWORD ) ;
|
|
t_Status = RegQueryValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_FILE_SIZE ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) &t_Size ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
m_DebugFileSize = t_Size ;
|
|
|
|
if (m_DebugFileSize < MIN_FILE_SIZE)
|
|
{
|
|
m_DebugFileSize = MIN_FILE_SIZE ;
|
|
}
|
|
}
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: LoadRegistry_Level ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
DWORD t_Level ;
|
|
DWORD t_ValueType = REG_DWORD ;
|
|
DWORD t_ValueLength = sizeof ( DWORD ) ;
|
|
t_Status = RegQueryValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_LEVEL_NAME ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) &t_Level ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
m_DebugLevel = t_Level ;
|
|
}
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: LoadRegistry_File ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
TCHAR *t_File = NULL ;
|
|
DWORD t_ValueType = REG_SZ ;
|
|
DWORD t_ValueLength = 0 ;
|
|
|
|
t_Status = RegQueryValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_FILE_NAME ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) t_File ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
t_File = new TCHAR [ t_ValueLength ] ;
|
|
|
|
t_Status = RegQueryValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_FILE_NAME ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) t_File ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( (t_Status == ERROR_SUCCESS) && t_File && (*t_File != _TEXT('\0') ) )
|
|
{
|
|
// Expand the name and store the expanded
|
|
// name in m_DebugFile.
|
|
SetExpandedFile(t_File);
|
|
|
|
// Set the unexpanded name in
|
|
// m_tstrDebugFileUnexpandedName...
|
|
SetFile ( t_File ) ;
|
|
}
|
|
else
|
|
{
|
|
SetDefaultFile();
|
|
}
|
|
|
|
delete [] t_File ;
|
|
}
|
|
else
|
|
{
|
|
SetDefaultFile();
|
|
}
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: LoadRegistry_Type ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
TCHAR *t_Type = NULL ;
|
|
DWORD t_ValueType = REG_SZ ;
|
|
DWORD t_ValueLength = 0 ;
|
|
|
|
t_Status = RegQueryValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_TYPE_NAME ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) t_Type ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
t_Type = new TCHAR [ t_ValueLength ] ;
|
|
|
|
t_Status = RegQueryValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_TYPE_NAME ,
|
|
0,
|
|
&t_ValueType ,
|
|
( LPBYTE ) t_Type ,
|
|
&t_ValueLength
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
if ( _tcscmp ( t_Type , _T("Debugger") ) == 0 )
|
|
{
|
|
SetContext ( DEBUG ) ;
|
|
}
|
|
else
|
|
{
|
|
SetContext ( FILE ) ;
|
|
}
|
|
}
|
|
|
|
delete [] t_Type;
|
|
}
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SetRegistry()
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection) ;
|
|
|
|
SetRegistry_Logging () ;
|
|
SetRegistry_Level () ;
|
|
SetRegistry_File () ;
|
|
SetRegistry_FileSize () ;
|
|
SetRegistry_Type () ;
|
|
|
|
LeaveCriticalSection(&m_CriticalSection) ;
|
|
}
|
|
|
|
void ProvDebugLog :: SetRegistry_Logging ()
|
|
{
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
LOG_KEY,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
DWORD t_Logging = m_Logging ;
|
|
DWORD t_ValueType = REG_DWORD ;
|
|
DWORD t_ValueLength = sizeof ( DWORD ) ;
|
|
|
|
t_Status = RegSetValueEx (
|
|
|
|
t_LogKey ,
|
|
LOGGING_ON ,
|
|
0,
|
|
t_ValueType ,
|
|
( LPBYTE ) &t_Logging ,
|
|
t_ValueLength
|
|
) ;
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SetRegistry_FileSize ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
DWORD t_Level = m_DebugFileSize ;
|
|
DWORD t_ValueType = REG_DWORD ;
|
|
DWORD t_ValueLength = sizeof ( DWORD ) ;
|
|
t_Status = RegSetValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_FILE_SIZE ,
|
|
0,
|
|
t_ValueType ,
|
|
( LPBYTE ) &t_Level ,
|
|
t_ValueLength
|
|
) ;
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SetRegistry_Level ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
DWORD t_Level = m_DebugLevel ;
|
|
DWORD t_ValueType = REG_DWORD ;
|
|
DWORD t_ValueLength = sizeof ( DWORD ) ;
|
|
t_Status = RegSetValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_LEVEL_NAME ,
|
|
0,
|
|
t_ValueType ,
|
|
( LPBYTE ) &t_Level ,
|
|
t_ValueLength
|
|
) ;
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SetRegistry_File ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
if ( m_DebugFileUnexpandedName )
|
|
{
|
|
TCHAR *t_File = m_DebugFileUnexpandedName ;
|
|
DWORD t_ValueType = REG_SZ ;
|
|
DWORD t_ValueLength = ( _tcslen ( t_File ) + 1 ) * sizeof ( TCHAR ) ;
|
|
|
|
t_Status = RegSetValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_FILE_NAME ,
|
|
0,
|
|
t_ValueType ,
|
|
( LPBYTE ) t_File ,
|
|
t_ValueLength
|
|
) ;
|
|
}
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SetRegistry_Type ()
|
|
{
|
|
if ( m_DebugComponent )
|
|
{
|
|
TCHAR *t_ComponentKeyString = ( TCHAR * ) malloc (
|
|
|
|
( _tcslen ( LOG_KEY_SLASH ) + _tcslen ( m_DebugComponent ) + 1 ) * sizeof ( TCHAR )
|
|
) ;
|
|
|
|
if (t_ComponentKeyString == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
_tcscpy ( t_ComponentKeyString , LOG_KEY_SLASH ) ;
|
|
_tcscat ( t_ComponentKeyString , m_DebugComponent ) ;
|
|
|
|
HKEY t_LogKey = NULL ;
|
|
|
|
LONG t_Status = RegCreateKeyEx (
|
|
|
|
HKEY_LOCAL_MACHINE,
|
|
t_ComponentKeyString,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&t_LogKey,
|
|
NULL
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
TCHAR *t_Debugger = _T("Debugger") ;
|
|
TCHAR *t_File = _T("File") ;
|
|
TCHAR *t_Type = ( m_DebugContext == DEBUG ) ? t_Debugger : t_File ;
|
|
DWORD t_ValueType = REG_SZ ;
|
|
DWORD t_ValueLength = ( _tcslen ( t_Type ) + 1 ) * sizeof ( TCHAR ) ;
|
|
|
|
t_Status = RegSetValueEx(
|
|
|
|
t_LogKey ,
|
|
LOG_TYPE_NAME ,
|
|
0,
|
|
t_ValueType ,
|
|
( LPBYTE ) t_Type ,
|
|
t_ValueLength
|
|
) ;
|
|
|
|
RegCloseKey ( t_LogKey ) ;
|
|
}
|
|
|
|
free ( t_ComponentKeyString ) ;
|
|
}
|
|
}
|
|
|
|
void ProvDebugLog :: SetEventNotification ()
|
|
{
|
|
g_ProvDebugLogThread->GetTaskObject ()->SetRegistryNotification () ;
|
|
}
|
|
|
|
BOOL ProvDebugLog :: Startup ()
|
|
{
|
|
EnterCriticalSection ( &s_CriticalSection ) ;
|
|
s_ReferenceCount++;
|
|
|
|
if ( ! s_Initialised )
|
|
{
|
|
ProvThreadObject::Startup();
|
|
g_ProvDebugLogThread = new ProvDebugThreadObject ( _TEXT("ProvDebugLogThread") ) ;
|
|
g_ProvDebugLogThread->BeginThread();
|
|
g_ProvDebugLogThread->WaitForStartup () ;
|
|
g_ProvDebugLogThread->ScheduleDebugTask();
|
|
SetEventNotification () ;
|
|
s_Initialised = TRUE ;
|
|
}
|
|
|
|
LeaveCriticalSection ( &s_CriticalSection ) ;
|
|
return TRUE ;
|
|
}
|
|
|
|
void ProvDebugLog :: Closedown ()
|
|
{
|
|
EnterCriticalSection ( &s_CriticalSection ) ;
|
|
s_ReferenceCount--;
|
|
|
|
if ( s_ReferenceCount == 0 )
|
|
{
|
|
g_ProvDebugLogThread->SignalThreadShutdown() ;
|
|
s_Initialised = FALSE ;
|
|
ProvThreadObject::Closedown();
|
|
}
|
|
|
|
LeaveCriticalSection ( &s_CriticalSection ) ;
|
|
}
|