// Tracer.cpp
|
|
// Implements the tracer class
|
|
// #include "stdafx.h"
|
#include "../TraceServer/TraceServer.h"
|
#include <stdio.h>
|
#include <sys/types.h>
|
#include <sys/timeb.h>
|
#include <stdarg.h> // for var args
|
|
#include "Tracer.h"
|
|
char *TraceLevels[] = {" NONE", "ERROR", " SPCL", " -1-", "STATE", " -2-", " -3-", " -4-", " SIG", " EE", " ARB", " -5-", " DET", " ALL"};
|
|
#define BUFFERSIZE 1024
|
|
Tracer::Tracer(const char *FacilityName, const char *SubFacilityName, const unsigned long Mask) {
|
InitializeTracing();
|
bEnabled = true;
|
SetFacilityName(FacilityName);
|
SetSubFacilityName(SubFacilityName);
|
SetSystemMask(Mask);
|
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_NONE,"NONE"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_ERROR,"ERROR"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_SPECIAL,"SPCL"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_STATE_TRANS,"STATE"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_SIGNIFICANT,"SIG"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_ENTRY_EXIT,"EE"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_ARBITRARY,"ARB"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_DETAILED,"DET"));
|
traceLevelName.insert(TRACENAMEMAP::value_type(SDI_LEVEL_ALL,"ALL"));
|
}
|
|
|
Tracer::~Tracer() {
|
UninitializeTracing();
|
}
|
|
|
|
void
|
Tracer::Enable(bool flag) {
|
bEnabled = flag;
|
}
|
|
|
|
void
|
Tracer::SetFacilityName(const char * name) {
|
_snprintf(facilityName, MAX_NAME_LENGTH-1, name);
|
facilityName[MAX_NAME_LENGTH-1] = '\0';
|
}
|
|
|
|
void
|
Tracer::SetSubFacilityName(const char * name) {
|
_snprintf(subFacilityName, MAX_NAME_LENGTH-1, name);
|
subFacilityName[MAX_NAME_LENGTH-1] = '\0';
|
}
|
|
char *
|
Tracer::GetFacilityName()
|
{
|
return facilityName;
|
}
|
|
char *
|
Tracer::GetSubFacilityName()
|
{
|
return subFacilityName;
|
}
|
|
void
|
Tracer::SetSystemMask(const unsigned long mask) {
|
SystemMask = mask;
|
}
|
|
|
|
void
|
Tracer::tracef(const unsigned long mask, const char * str_, ...) {
|
if (!bEnabled)
|
return;
|
|
if ((mask & SDI_SYSTEM_MASK) > (SystemMask & SDI_SYSTEM_MASK))
|
return;
|
|
char *temp = GetTraceBuffer();
|
if (!temp)
|
return;
|
|
char temp2[MAX_TRACE_LENGTH];
|
|
va_list arglist;
|
va_start(arglist, str_);
|
_vsnprintf(temp2, MAX_TRACE_LENGTH-1, str_, arglist);
|
va_end(arglist);
|
temp2[MAX_TRACE_LENGTH-1] = '\0';
|
int maskPosn = 0;
|
if (mask >= 0x100000)
|
{
|
maskPosn = 8 + (mask / 0x100000);
|
}
|
else
|
{
|
maskPosn = mask / 0x10000;
|
}
|
if (maskPosn > 13)
|
{
|
maskPosn = 13;
|
}
|
_snprintf(temp, MAX_TRACE_LENGTH-1, "%5s : %s : %s : %s", TraceLevels[maskPosn], facilityName, subFacilityName, temp2);
|
temp[MAX_TRACE_LENGTH-1] = '\0';
|
|
Trace(temp);
|
}
|
|
char *
|
Ascii2W(const char *input, char *output, int outputSizeBytes)
|
{
|
int result = MultiByteToWideChar
|
(
|
CP_ACP, // code page
|
MB_PRECOMPOSED, // character-type options
|
input, // string to map
|
-1, // number of bytes in string
|
(wchar_t *)output, // wide-character buffer
|
outputSizeBytes // size of buffer
|
);
|
if (result > 0)
|
{
|
return output;
|
}
|
else
|
{
|
return NULL;
|
}
|
}
|
|
char *
|
W2Ascii(const char *input, char *output, int outputSizeBytes)
|
{
|
BOOL defaultCharUsed;
|
int result = WideCharToMultiByte
|
(
|
CP_ACP,
|
0,
|
(wchar_t *)input,
|
-1,
|
output,
|
outputSizeBytes,
|
NULL,
|
&defaultCharUsed
|
);
|
if (result > 0)
|
{
|
return output;
|
}
|
else
|
{
|
return NULL;
|
}
|
}
|
|
char *
|
Ascii2T(const char *input, char *output, int outputSizeBytes)
|
{
|
char *result = NULL;
|
#ifdef _UNICODE
|
result = Ascii2W(input, output, outputSizeBytes);
|
#else
|
if (outputSizeBytes > strlen(input))
|
{
|
strcpy(output, input);
|
result = output;
|
}
|
#endif
|
return result;
|
}
|
|
char *
|
T2Ascii(const char *input, char *output, int outputSizeBytes)
|
{
|
char *result = NULL;
|
#ifdef _UNICODE
|
result = W2Ascii(input, output, outputSizeBytes);
|
#else
|
if (outputSizeBytes > strlen(input))
|
{
|
strcpy(output, input);
|
result = output;
|
}
|
#endif
|
return result;
|
}
|
|
|
bool
|
GetRegKeyBool(const HKEY Key, const char * KeyName, const char * ValueName, const bool defaultValue) {
|
|
// reads the value 'ValueName' of the key 'KeyName' under the hKey tree
|
DWORD KeyType, KeySize = 1000;
|
DWORD disposition;
|
BYTE Value[1001];
|
long result;
|
HKEY hKey;
|
char buffer[BUFFERSIZE];
|
|
|
strcpy((char *)Value, "");
|
Value[1000] = '\0';
|
|
result = RegCreateKeyEx(Key,
|
(LPTSTR)Ascii2T(KeyName, buffer, BUFFERSIZE),
|
0,
|
NULL,
|
REG_OPTION_NON_VOLATILE,
|
KEY_ALL_ACCESS,
|
NULL,
|
&hKey,
|
&disposition
|
);
|
|
if (result != 0)
|
return false;
|
|
result = RegQueryValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), NULL, &KeyType, Value, &KeySize);
|
if (result != 0) {
|
|
if (defaultValue == true)
|
strcpy((char *)Value, "true");
|
else
|
strcpy((char *)Value, "false");
|
|
KeyType = REG_SZ;
|
KeySize = strlen((char *)Value) + 1;
|
|
result = RegSetValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), 0, KeyType, (BYTE *)&Value, KeySize);
|
if (result != 0)
|
return false;
|
}
|
RegCloseKey(hKey);
|
|
if (_stricmp(T2Ascii((LPTSTR)Value, buffer, BUFFERSIZE), "true") == 0)
|
return true;
|
else
|
return false;
|
}
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
|
std::string
|
GetRegKeyString(const HKEY Key, const char * KeyName, const char * ValueName, const char * defaultValue) {
|
|
// reads the value 'ValueName' of the key 'KeyName' under the hKey tree
|
DWORD KeyType, KeySize = 1000;
|
DWORD disposition;
|
BYTE Value[1001];
|
long result;
|
HKEY hKey;
|
char buffer[BUFFERSIZE];
|
|
strcpy((char *)Value, "");
|
Value[1000] = '\0';
|
|
result = RegCreateKeyEx(Key,
|
(LPTSTR)Ascii2T(KeyName, buffer, BUFFERSIZE),
|
0,
|
NULL,
|
REG_OPTION_NON_VOLATILE,
|
KEY_ALL_ACCESS,
|
NULL,
|
&hKey,
|
&disposition
|
);
|
|
if (result != 0)
|
return "";
|
|
result = RegQueryValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), NULL, &KeyType, Value, &KeySize);
|
if (result != 0) {
|
strcpy((char *)Value, defaultValue);
|
KeyType = REG_SZ;
|
KeySize = strlen(defaultValue) + 1;
|
result = RegSetValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), 0, KeyType, (BYTE *)&Value, KeySize);
|
if (result != 0)
|
return "";
|
}
|
RegCloseKey(hKey);
|
|
return std::string(T2Ascii((LPTSTR)Value, buffer, BUFFERSIZE));
|
|
}
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
|
long
|
GetRegKeyLong(const HKEY Key, const char * KeyName, const char * ValueName, const long defaultValue) {
|
|
// reads the value 'ValueName' of the key 'KeyName' under the hKey tree
|
DWORD KeyType, KeySize = 4;
|
DWORD disposition;
|
long Value;
|
long result;
|
HKEY hKey;
|
char buffer[BUFFERSIZE];
|
|
result = RegCreateKeyEx(Key,
|
(LPTSTR)Ascii2T(KeyName, buffer, BUFFERSIZE),
|
0,
|
NULL,
|
REG_OPTION_NON_VOLATILE,
|
KEY_ALL_ACCESS,
|
NULL,
|
&hKey,
|
&disposition
|
);
|
|
if (result != 0)
|
return 0;
|
|
result = RegQueryValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), NULL, &KeyType, (BYTE *)&Value, &KeySize);
|
if (result != 0) {
|
Value = defaultValue;
|
KeyType = REG_DWORD;
|
KeySize = 4;
|
result = RegSetValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), 0, KeyType, (BYTE *)&Value, KeySize);
|
if (result != 0)
|
return 0;
|
}
|
RegCloseKey(hKey);
|
|
return Value;
|
|
}
|
|
// ===================================================================================================
|
|
|
long
|
SetRegKeyBool(const HKEY Key, const char * KeyName, const char * ValueName, const bool newValue) {
|
|
// reads the value 'ValueName' of the key 'KeyName' under the hKey tree
|
DWORD KeyType, KeySize = 1000;
|
DWORD disposition;
|
BYTE Value[1001];
|
long result;
|
HKEY hKey;
|
char buffer[BUFFERSIZE];
|
|
result = RegCreateKeyEx(Key,
|
(LPTSTR)Ascii2T(KeyName, buffer, BUFFERSIZE),
|
0,
|
NULL,
|
REG_OPTION_NON_VOLATILE,
|
KEY_ALL_ACCESS,
|
NULL,
|
&hKey,
|
&disposition
|
);
|
|
if (result != 0)
|
return -10;
|
|
if (newValue == true)
|
strcpy((char *)Value, "true");
|
else
|
strcpy((char *)Value, "false");
|
|
KeyType = REG_SZ;
|
KeySize = strlen((char *)Value) + 1;
|
|
result = RegSetValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), 0, KeyType, (BYTE *)&Value, KeySize);
|
if (result != 0)
|
return -20;
|
|
RegCloseKey(hKey);
|
return 0;
|
}
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
|
long
|
SetRegKeyString(const HKEY Key, const char * KeyName, const char * ValueName, const char * newValue) {
|
|
// reads the value 'ValueName' of the key 'KeyName' under the hKey tree
|
DWORD KeyType, KeySize = 1000;
|
DWORD disposition;
|
BYTE Value[1001];
|
long result;
|
HKEY hKey;
|
char buffer[BUFFERSIZE];
|
|
result = RegCreateKeyEx(Key,
|
(LPTSTR)Ascii2T(KeyName, buffer, BUFFERSIZE),
|
0,
|
NULL,
|
REG_OPTION_NON_VOLATILE,
|
KEY_ALL_ACCESS,
|
NULL,
|
&hKey,
|
&disposition
|
);
|
|
if (result != 0)
|
return -10;
|
|
strcpy((char *)Value, newValue);
|
KeyType = REG_SZ;
|
KeySize = strlen((char *)Value) + 1;
|
|
result = RegSetValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), 0, KeyType, (BYTE *)&Value, KeySize);
|
if (result != 0)
|
return -20;
|
|
RegCloseKey(hKey);
|
|
return 0;
|
|
}
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
|
long
|
SetRegKeyLong(const HKEY Key, const char * KeyName, const char * ValueName, const long newValue) {
|
|
// reads the value 'ValueName' of the key 'KeyName' under the hKey tree
|
DWORD KeyType, KeySize = 4;
|
DWORD disposition;
|
long Value;
|
long result;
|
HKEY hKey;
|
char buffer[BUFFERSIZE];
|
|
result = RegCreateKeyEx(Key,
|
(LPTSTR)Ascii2T(KeyName, buffer, BUFFERSIZE),
|
0,
|
NULL,
|
REG_OPTION_NON_VOLATILE,
|
KEY_ALL_ACCESS,
|
NULL,
|
&hKey,
|
&disposition
|
);
|
|
if (result != 0)
|
return -10;
|
|
Value = newValue;
|
KeyType = REG_DWORD;
|
KeySize = 4;
|
|
result = RegSetValueEx(hKey, (LPTSTR)Ascii2T(ValueName, buffer, BUFFERSIZE), 0, KeyType, (BYTE *)&Value, KeySize);
|
if (result != 0)
|
return -20;
|
|
RegCloseKey(hKey);
|
|
return Value;
|
|
}
|
|
|
|
