1416 lines
35 KiB
C++
1416 lines
35 KiB
C++
//***************************************************************************
|
|
|
|
//
|
|
|
|
// File:
|
|
|
|
//
|
|
|
|
// Module: MS SNMP Provider
|
|
|
|
//
|
|
|
|
// Purpose:
|
|
|
|
//
|
|
|
|
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
#include <provexpt.h>
|
|
#include <snmpstd.h>
|
|
#include <snmptempl.h>
|
|
#include <snmpmt.h>
|
|
#include <string.h>
|
|
#include <snmpmt.h>
|
|
#include <snmptempl.h>
|
|
#include <snmpcont.h>
|
|
#include <snmplog.h>
|
|
#include <snmpevt.h>
|
|
#include <snmpthrd.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 SnmpDebugLog :: s_ReferenceCount = 0 ;
|
|
CRITICAL_SECTION SnmpDebugLog :: s_CriticalSection ;
|
|
|
|
CMap <SnmpDebugLog *,SnmpDebugLog *,SnmpDebugLog *,SnmpDebugLog *> g_SnmpDebugLogMap ;
|
|
CRITICAL_SECTION g_SnmpDebugLogMapCriticalSection ;
|
|
|
|
class SnmpDebugTaskObject : public SnmpTaskObject
|
|
{
|
|
private:
|
|
|
|
HKEY m_LogKey ;
|
|
|
|
protected:
|
|
public:
|
|
|
|
SnmpDebugTaskObject () ;
|
|
~SnmpDebugTaskObject () ;
|
|
|
|
void Process () ;
|
|
|
|
void SetRegistryNotification () ;
|
|
} ;
|
|
|
|
SnmpDebugTaskObject :: SnmpDebugTaskObject () : m_LogKey ( NULL )
|
|
{
|
|
}
|
|
|
|
SnmpDebugTaskObject :: ~SnmpDebugTaskObject ()
|
|
{
|
|
if ( m_LogKey )
|
|
RegCloseKey ( m_LogKey ) ;
|
|
}
|
|
|
|
void SnmpDebugTaskObject :: Process ()
|
|
{
|
|
SnmpDebugLog *t_SnmpDebugLog = NULL ;
|
|
EnterCriticalSection ( &g_SnmpDebugLogMapCriticalSection ) ;
|
|
|
|
POSITION t_Position = g_SnmpDebugLogMap.GetStartPosition () ;
|
|
while ( t_Position )
|
|
{
|
|
g_SnmpDebugLogMap.GetNextAssoc ( t_Position , t_SnmpDebugLog , t_SnmpDebugLog ) ;
|
|
t_SnmpDebugLog->LoadRegistry () ;
|
|
t_SnmpDebugLog->SetRegistry () ;
|
|
}
|
|
|
|
LeaveCriticalSection ( &g_SnmpDebugLogMapCriticalSection ) ;
|
|
SetRegistryNotification () ;
|
|
|
|
}
|
|
|
|
void SnmpDebugTaskObject :: 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 )
|
|
{
|
|
t_Status = RegNotifyChangeKeyValue (
|
|
|
|
m_LogKey ,
|
|
TRUE ,
|
|
REG_NOTIFY_CHANGE_LAST_SET ,
|
|
GetHandle () ,
|
|
TRUE
|
|
) ;
|
|
|
|
if ( t_Status == ERROR_SUCCESS )
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
class SnmpDebugThreadObject : public SnmpThreadObject
|
|
{
|
|
private:
|
|
|
|
SnmpDebugTaskObject *m_SnmpDebugTaskObject ;
|
|
|
|
protected:
|
|
|
|
void Uninitialise () { delete this ; }
|
|
|
|
public:
|
|
|
|
SnmpDebugThreadObject ( const char *a_Thread ) ;
|
|
~SnmpDebugThreadObject () ;
|
|
|
|
SnmpDebugTaskObject *GetTaskObject () ;
|
|
} ;
|
|
|
|
SnmpDebugThreadObject *g_SnmpDebugLogThread = NULL ;
|
|
|
|
SnmpDebugLog *SnmpDebugLog :: s_SnmpDebugLog = NULL ;
|
|
BOOL SnmpDebugLog :: s_Initialised = FALSE ;
|
|
|
|
SnmpDebugThreadObject :: SnmpDebugThreadObject ( const char *a_Thread )
|
|
: SnmpThreadObject ( a_Thread ) , m_SnmpDebugTaskObject ( NULL )
|
|
{
|
|
m_SnmpDebugTaskObject = new SnmpDebugTaskObject ;
|
|
SnmpDebugLog :: s_SnmpDebugLog = new SnmpDebugLog ( _T("WBEMSNMP") ) ;
|
|
ScheduleTask ( *m_SnmpDebugTaskObject ) ;
|
|
}
|
|
|
|
SnmpDebugThreadObject :: ~SnmpDebugThreadObject ()
|
|
{
|
|
delete SnmpDebugLog :: s_SnmpDebugLog ;
|
|
SnmpDebugLog :: s_SnmpDebugLog = NULL ;
|
|
|
|
if ( m_SnmpDebugTaskObject != NULL )
|
|
{
|
|
ReapTask ( *m_SnmpDebugTaskObject ) ;
|
|
delete m_SnmpDebugTaskObject ;
|
|
}
|
|
}
|
|
|
|
SnmpDebugTaskObject *SnmpDebugThreadObject :: GetTaskObject ()
|
|
{
|
|
return m_SnmpDebugTaskObject ;
|
|
}
|
|
|
|
SnmpDebugLog :: SnmpDebugLog (
|
|
|
|
const TCHAR *a_DebugComponent
|
|
|
|
) : m_Logging ( FALSE ) ,
|
|
m_DebugLevel ( 0 ) ,
|
|
m_DebugFileSize ( DEFAULT_FILE_SIZE ),
|
|
m_DebugContext ( SnmpDebugContext :: FILE ) ,
|
|
m_DebugFile ( NULL ) ,
|
|
m_DebugFileUnexpandedName ( NULL ) ,
|
|
m_DebugFileHandle ( INVALID_HANDLE_VALUE ) ,
|
|
m_DebugComponent ( NULL )
|
|
{
|
|
EnterCriticalSection ( &g_SnmpDebugLogMapCriticalSection ) ;
|
|
m_CriticalSection.Lock () ;
|
|
|
|
g_SnmpDebugLogMap [ this ] = this ;
|
|
|
|
if ( a_DebugComponent )
|
|
{
|
|
m_DebugComponent = _tcsdup ( a_DebugComponent ) ;
|
|
}
|
|
|
|
LoadRegistry () ;
|
|
SetRegistry () ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
LeaveCriticalSection ( &g_SnmpDebugLogMapCriticalSection ) ;
|
|
}
|
|
|
|
SnmpDebugLog :: ~SnmpDebugLog ()
|
|
{
|
|
EnterCriticalSection ( &g_SnmpDebugLogMapCriticalSection ) ;
|
|
m_CriticalSection.Lock () ;
|
|
|
|
g_SnmpDebugLogMap.RemoveKey ( this ) ;
|
|
|
|
CloseOutput () ;
|
|
|
|
if (m_DebugComponent)
|
|
{
|
|
free ( m_DebugComponent ) ;
|
|
}
|
|
|
|
if (m_DebugFile)
|
|
{
|
|
free ( m_DebugFile ) ;
|
|
}
|
|
|
|
if (m_DebugFileUnexpandedName)
|
|
{
|
|
free ( m_DebugFileUnexpandedName ) ;
|
|
}
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
LeaveCriticalSection ( &g_SnmpDebugLogMapCriticalSection ) ;
|
|
}
|
|
|
|
void SnmpDebugLog :: 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))
|
|
{
|
|
_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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: OpenFileForOutput ()
|
|
{
|
|
if ( m_DebugFile )
|
|
{
|
|
m_DebugFileHandle = CreateFile (
|
|
|
|
m_DebugFile ,
|
|
GENERIC_WRITE ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
NULL ,
|
|
OPEN_EXISTING ,
|
|
FILE_ATTRIBUTE_NORMAL ,
|
|
NULL
|
|
) ;
|
|
|
|
if ( m_DebugFileHandle == INVALID_HANDLE_VALUE )
|
|
{
|
|
m_DebugFileHandle = CreateFile (
|
|
|
|
m_DebugFile ,
|
|
GENERIC_WRITE ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
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 SnmpDebugLog :: OpenOutput ()
|
|
{
|
|
switch ( m_DebugContext )
|
|
{
|
|
case FILE:
|
|
{
|
|
OpenFileForOutput () ;
|
|
}
|
|
break ;
|
|
|
|
case DEBUG:
|
|
default:
|
|
{
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
void SnmpDebugLog :: FlushOutput ()
|
|
{
|
|
switch ( m_DebugContext )
|
|
{
|
|
case FILE:
|
|
{
|
|
if ( m_DebugFileHandle != INVALID_HANDLE_VALUE )
|
|
{
|
|
FlushFileBuffers ( m_DebugFileHandle ) ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case DEBUG:
|
|
default:
|
|
{
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
void SnmpDebugLog :: 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 SnmpDebugLog :: Write ( const TCHAR *a_DebugFormatString , ... )
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
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 ) ;
|
|
}
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: WriteFileAndLine ( const char *a_File , const ULONG a_Line , const TCHAR *a_DebugFormatString , ... )
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
if ( m_Logging )
|
|
{
|
|
#ifdef BUILD_WITH_FILE_AND_LINE
|
|
|
|
TCHAR t_OutputDebugString [ MAX_MESSAGE_SIZE ] ;
|
|
char t_FileLineString [ HALF_MAX_MESSAGE_SIZE ] ;
|
|
|
|
_snprintf ( t_FileLineString , HALF_MAX_MESSAGE_SIZE , "\r\n(%s):(%lu):" , a_File , a_Line ) ;
|
|
size_t textLength = mbstowcs ( t_OutputDebugString , t_FileLineString , HALF_MAX_MESSAGE_SIZE ) ;
|
|
if ( textLength != -1 )
|
|
{
|
|
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 ] ;
|
|
char t_FileLineString [ HALF_MAX_MESSAGE_SIZE ] ;
|
|
|
|
_snprintf ( t_FileLineString , HALF_MAX_MESSAGE_SIZE , "\r\n" ) ;
|
|
size_t textLength = mbstowcs ( t_OutputDebugString , t_FileLineString , HALF_MAX_MESSAGE_SIZE ) ;
|
|
if ( textLength != -1 )
|
|
{
|
|
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
|
|
|
|
}
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: Flush ()
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
FlushOutput () ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: SetLogging ( BOOL a_Logging )
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
m_Logging = a_Logging ;
|
|
|
|
m_CriticalSection.Lock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: SetLevel ( const DWORD &a_DebugLevel )
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
m_DebugLevel = a_DebugLevel ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: SetContext ( const enum SnmpDebugContext &a_DebugContext )
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
m_DebugContext = a_DebugContext ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
enum SnmpDebugLog :: SnmpDebugContext SnmpDebugLog :: GetContext ()
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
SnmpDebugContext t_Context = m_DebugContext ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
|
|
return t_Context ;
|
|
}
|
|
|
|
void SnmpDebugLog ::CommitContext ()
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
CloseOutput () ;
|
|
OpenOutput () ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog ::SetFile ( const TCHAR *a_File )
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
if (m_DebugFileUnexpandedName)
|
|
{
|
|
free ( m_DebugFileUnexpandedName ) ;
|
|
}
|
|
|
|
m_DebugFileUnexpandedName = _tcsdup ( a_File ) ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog::SetExpandedFile(
|
|
const TCHAR *a_RawFileName)
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
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(...)
|
|
{
|
|
m_CriticalSection.Unlock () ;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: LoadRegistry()
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
LoadRegistry_Logging () ;
|
|
LoadRegistry_Level () ;
|
|
LoadRegistry_File () ;
|
|
LoadRegistry_Type () ;
|
|
LoadRegistry_FileSize ();
|
|
CommitContext () ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: SetRegistry()
|
|
{
|
|
m_CriticalSection.Lock () ;
|
|
|
|
SetRegistry_Logging () ;
|
|
SetRegistry_Level () ;
|
|
SetRegistry_File () ;
|
|
SetRegistry_FileSize () ;
|
|
SetRegistry_Type () ;
|
|
|
|
m_CriticalSection.Unlock () ;
|
|
}
|
|
|
|
void SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: 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 SnmpDebugLog :: SetEventNotification ()
|
|
{
|
|
g_SnmpDebugLogThread->GetTaskObject ()->SetRegistryNotification () ;
|
|
}
|
|
|
|
BOOL SnmpDebugLog :: Startup ()
|
|
{
|
|
EnterCriticalSection ( &s_CriticalSection ) ;
|
|
s_ReferenceCount++ ;
|
|
|
|
if ( ! s_Initialised )
|
|
{
|
|
SnmpThreadObject::Startup();
|
|
g_SnmpDebugLogThread = new SnmpDebugThreadObject ( "SnmpDebugLogThread" ) ;
|
|
g_SnmpDebugLogThread->BeginThread () ;
|
|
g_SnmpDebugLogThread->WaitForStartup () ;
|
|
SetEventNotification () ;
|
|
s_Initialised = TRUE ;
|
|
}
|
|
|
|
LeaveCriticalSection ( &s_CriticalSection ) ;
|
|
|
|
return TRUE ;
|
|
}
|
|
|
|
void SnmpDebugLog :: Closedown ()
|
|
{
|
|
EnterCriticalSection ( &s_CriticalSection ) ;
|
|
s_ReferenceCount--;
|
|
|
|
if ( s_ReferenceCount == 0 )
|
|
{
|
|
g_SnmpDebugLogThread->SignalThreadShutdown() ;
|
|
s_Initialised = FALSE ;
|
|
SnmpThreadObject::Closedown();
|
|
}
|
|
|
|
LeaveCriticalSection ( &s_CriticalSection ) ;
|
|
}
|