761 lines
16 KiB
C++
761 lines
16 KiB
C++
// Utilities.cpp: implementation of the CUtilities class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
//***************************************************************************
|
|
//
|
|
// judyp May 1999
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "stdafx.h"
|
|
|
|
#pragma warning (disable : 4786)
|
|
#pragma warning (disable : 4275)
|
|
|
|
#include <iostream>
|
|
#include <strstream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <map>
|
|
#include <list>
|
|
|
|
using namespace std;
|
|
|
|
#include <tchar.h>
|
|
#include <windows.h>
|
|
#ifdef NONNT5
|
|
typedef unsigned long ULONG_PTR;
|
|
#endif
|
|
#include <wmistr.h>
|
|
#include <guiddef.h>
|
|
#include <initguid.h>
|
|
#include <evntrace.h>
|
|
|
|
#include <malloc.h>
|
|
|
|
#include <WTYPES.H>
|
|
#include "t_string.h"
|
|
#include <tchar.h>
|
|
#include <list>
|
|
|
|
|
|
#include "Persistor.h"
|
|
#include "Logger.h"
|
|
|
|
#include "StructureWrappers.h"
|
|
#include "StructureWapperHelpers.h"
|
|
|
|
#include "TCOData.h"
|
|
#include "Utilities.h"
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
TCHAR *NewTCHAR(const TCHAR *ptcToCopy)
|
|
{
|
|
if (ptcToCopy == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int nString = _tcsclen(ptcToCopy) + 1;
|
|
int nTCHAR = sizeof(TCHAR);
|
|
|
|
int nLen = nString * (nTCHAR);
|
|
|
|
TCHAR *pNew = (TCHAR*) malloc(nLen);
|
|
|
|
_tcscpy(pNew,ptcToCopy);
|
|
|
|
return pNew;
|
|
}
|
|
|
|
LPSTR NewLPSTR(LPCWSTR lpwstrToCopy)
|
|
{
|
|
int nLen = (wcslen(lpwstrToCopy) + 1) * sizeof(WCHAR);
|
|
LPSTR pNew = (char *)malloc( nLen );
|
|
|
|
wcstombs(pNew, lpwstrToCopy, nLen);
|
|
|
|
return pNew;
|
|
}
|
|
|
|
LPWSTR NewLPWSTR(LPCSTR lpstrToCopy)
|
|
{
|
|
int nLen = (strlen(lpstrToCopy) + 1);
|
|
LPWSTR pNew = (WCHAR *)malloc( nLen * sizeof(WCHAR));
|
|
mbstowcs(pNew, lpstrToCopy, nLen);
|
|
|
|
return pNew;
|
|
|
|
}
|
|
|
|
LPTSTR DecodeStatus(IN ULONG Status)
|
|
{
|
|
LPTSTR lptstrError = (LPTSTR) malloc (MAX_STR * (sizeof(TCHAR)));
|
|
|
|
memset( lptstrError, 0, MAX_STR );
|
|
|
|
FormatMessage(
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL,
|
|
Status,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
|
lptstrError,
|
|
MAX_STR,
|
|
NULL );
|
|
|
|
for (int i = 0; i < MAX_STR; i++)
|
|
{
|
|
if (lptstrError[i] == 0x0d)
|
|
{
|
|
lptstrError[i] = _T('\0');
|
|
break;
|
|
}
|
|
}
|
|
|
|
return lptstrError;
|
|
}
|
|
|
|
int GetFileList
|
|
(LPTSTR lptstrPath, LPTSTR lptstrFileType, list<t_string> &rList)
|
|
{
|
|
t_string tsFind;
|
|
|
|
tsFind = lptstrPath;
|
|
tsFind += _T("\\");
|
|
tsFind += lptstrFileType;
|
|
|
|
|
|
WIN32_FIND_DATA wfdFile;
|
|
HANDLE hFindHandle =
|
|
FindFirstFile(tsFind.c_str(), &wfdFile);
|
|
|
|
if (hFindHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
if ((_tcscmp(wfdFile.cFileName,_T(".")) != 0) &&
|
|
(_tcscmp(wfdFile.cFileName,_T("..")) != 0))
|
|
{
|
|
tsFind = lptstrPath;
|
|
tsFind += _T("\\");
|
|
tsFind += wfdFile.cFileName;
|
|
rList.push_back(tsFind);
|
|
tsFind.erase();
|
|
}
|
|
|
|
while (FindNextFile(hFindHandle, &wfdFile))
|
|
{
|
|
if ((_tcscmp(wfdFile.cFileName,_T(".")) != 0) &&
|
|
(_tcscmp(wfdFile.cFileName,_T("..")) != 0))
|
|
{
|
|
tsFind = lptstrPath;
|
|
tsFind += _T("\\");
|
|
tsFind += wfdFile.cFileName;
|
|
rList.push_back(tsFind);
|
|
tsFind.erase();
|
|
}
|
|
}
|
|
|
|
FindClose(hFindHandle);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
// From Q 118626
|
|
BOOL IsAdmin()
|
|
{
|
|
HANDLE hAccessToken;
|
|
UCHAR InfoBuffer[1024];
|
|
PTOKEN_GROUPS ptgGroups = (PTOKEN_GROUPS)InfoBuffer;
|
|
DWORD dwInfoBufferSize;
|
|
PSID psidAdministrators;
|
|
SID_IDENTIFIER_AUTHORITY siaNtAuthority = SECURITY_NT_AUTHORITY;
|
|
UINT x;
|
|
BOOL bSuccess;
|
|
|
|
if(!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE,
|
|
&hAccessToken )) {
|
|
if(GetLastError() != ERROR_NO_TOKEN)
|
|
return FALSE;
|
|
//
|
|
// retry against process token if no thread token exists
|
|
//
|
|
if(!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY,
|
|
&hAccessToken))
|
|
return FALSE;
|
|
}
|
|
|
|
bSuccess = GetTokenInformation(hAccessToken,TokenGroups,InfoBuffer,
|
|
1024, &dwInfoBufferSize);
|
|
|
|
CloseHandle(hAccessToken);
|
|
|
|
if(!bSuccess )
|
|
return FALSE;
|
|
|
|
if(!AllocateAndInitializeSid(&siaNtAuthority, 2,
|
|
SECURITY_BUILTIN_DOMAIN_RID,
|
|
DOMAIN_ALIAS_RID_ADMINS,
|
|
0, 0, 0, 0, 0, 0,
|
|
&psidAdministrators))
|
|
return FALSE;
|
|
|
|
// assume that we don't find the admin SID.
|
|
bSuccess = FALSE;
|
|
|
|
for(x=0;x<ptgGroups->GroupCount;x++)
|
|
{
|
|
if( EqualSid(psidAdministrators, ptgGroups->Groups[x].Sid) )
|
|
{
|
|
bSuccess = TRUE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
FreeSid(psidAdministrators);
|
|
return bSuccess;
|
|
}
|
|
|
|
t_string GUIDToTString(GUID Guid)
|
|
{
|
|
t_strstream strStream;
|
|
t_string tsOut;
|
|
|
|
strStream << _T("{");
|
|
|
|
strStream.fill(_T('0'));
|
|
strStream.width(8);
|
|
strStream.flags(ios_base::right);
|
|
|
|
strStream << hex << Guid.Data1;
|
|
|
|
strStream << _T("-");
|
|
|
|
strStream.width(4);
|
|
|
|
strStream << hex << Guid.Data2;
|
|
|
|
strStream << _T("-");
|
|
|
|
strStream << hex << Guid.Data3;
|
|
|
|
strStream << _T("-");
|
|
|
|
// Data4 specifies an array of 8 bytes. The first 2 bytes contain
|
|
// the third group of 4 hexadecimal digits. The remaining 6 bytes
|
|
// contain the final 12 hexadecimal digits.
|
|
|
|
#ifndef _UNICODE
|
|
int i;
|
|
|
|
strStream.width(1);
|
|
|
|
BYTE Byte;
|
|
int Int;
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
Byte = Guid.Data4[i];
|
|
Byte = Byte >> 4;
|
|
Int = Byte;
|
|
strStream << hex << Int;
|
|
Byte = Guid.Data4[i];
|
|
Byte = 0x0f & Byte;
|
|
Int = Byte;
|
|
strStream << hex << Int;
|
|
}
|
|
|
|
strStream << _T("-");
|
|
|
|
strStream.width(1);
|
|
|
|
|
|
for (i = 2; i < 8; i++)
|
|
{
|
|
BYTE Byte = Guid.Data4[i];
|
|
Byte = Byte >> 4;
|
|
Int = Byte;
|
|
strStream << hex << Int;
|
|
Byte = Guid.Data4[i];
|
|
Byte = 0x0f & Byte;
|
|
Int = Byte;
|
|
strStream << hex << Int;
|
|
}
|
|
#else
|
|
int i;
|
|
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
TCHAR tc = Guid.Data4[i];
|
|
// For some reason the width is reset each time through the
|
|
// loop to be one.
|
|
strStream.width(2);
|
|
strStream << hex << tc;
|
|
}
|
|
|
|
strStream << _T("-");
|
|
|
|
BYTE Byte;
|
|
strStream.width(1);
|
|
for (i = 2; i < 8; i++)
|
|
{
|
|
Byte = Guid.Data4[i];
|
|
Byte = Byte >> 4;
|
|
strStream << hex << Byte;
|
|
Byte = Guid.Data4[i];
|
|
Byte = 0x0f & Byte;
|
|
strStream << hex << Byte;
|
|
}
|
|
#endif
|
|
|
|
strStream << _T("}");
|
|
|
|
strStream >> tsOut;
|
|
|
|
return tsOut;
|
|
}
|
|
|
|
LPTSTR LPTSTRFromGuid(GUID Guid)
|
|
{
|
|
t_string tsGuid = GUIDToTString(Guid);
|
|
return NewTCHAR(tsGuid.c_str());
|
|
}
|
|
|
|
t_string ULONGVarToTString(ULONG ul, bool bHex)
|
|
{
|
|
t_string tsTemp;
|
|
t_strstream strStream;
|
|
|
|
if (bHex)
|
|
{
|
|
strStream.width(8);
|
|
strStream.fill('0');
|
|
strStream.flags(ios_base::right);
|
|
strStream << hex << ul;
|
|
}
|
|
else
|
|
{
|
|
strStream << ul;
|
|
}
|
|
|
|
strStream >> tsTemp;
|
|
|
|
if (bHex)
|
|
{
|
|
t_string tsHex;
|
|
tsHex = _T("0x");
|
|
tsHex += tsTemp;
|
|
return tsHex;
|
|
}
|
|
else
|
|
{
|
|
return tsTemp;
|
|
}
|
|
}
|
|
|
|
ULONG InitializePropsArray
|
|
(PEVENT_TRACE_PROPERTIES &pPropsArray, int nInstances)
|
|
{
|
|
pPropsArray =
|
|
(PEVENT_TRACE_PROPERTIES) malloc
|
|
(sizeof(EVENT_TRACE_PROPERTIES) * nInstances);
|
|
|
|
RtlZeroMemory(pPropsArray, sizeof(EVENT_TRACE_PROPERTIES) * nInstances);
|
|
|
|
for (int i = 0; i < nInstances; i++)
|
|
{
|
|
pPropsArray[i].LoggerName = (TCHAR *) malloc (sizeof(TCHAR) * MAX_STR);
|
|
RtlZeroMemory(pPropsArray[i].LoggerName, sizeof(TCHAR) * MAX_STR);
|
|
pPropsArray[i].LogFileName = (TCHAR *) malloc (sizeof(TCHAR) * MAX_STR);
|
|
RtlZeroMemory(pPropsArray[i].LogFileName, sizeof(TCHAR) * MAX_STR);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
ULONG FreePropsArray
|
|
(PEVENT_TRACE_PROPERTIES &pPropsArray, int nInstances)
|
|
{
|
|
for (int i = 0; i < nInstances; i++)
|
|
{
|
|
free(pPropsArray[i].LoggerName);
|
|
free(pPropsArray[i].LogFileName);
|
|
}
|
|
|
|
free(pPropsArray);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int OpenLogFiles
|
|
( LPCTSTR lpctstrTCODetailFile,
|
|
CLogger *&pDetailLogger,
|
|
LPTSTR *plpstrReturnedError
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
t_string tsError;
|
|
|
|
if (lpctstrTCODetailFile)
|
|
{
|
|
// Open *our* logger file.
|
|
pDetailLogger = new CLogger(lpctstrTCODetailFile, false);
|
|
hr = pDetailLogger->GetOpenStatus();
|
|
if (FAILED (hr))
|
|
{
|
|
tsError = _T("Could not open detail log file \"");
|
|
tsError += lpctstrTCODetailFile;
|
|
tsError += _T("\".");
|
|
*plpstrReturnedError = NewTCHAR(tsError.c_str());
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
int LogDetailBeforeCall
|
|
( CLogger *pDetailLogger,
|
|
TCOData *pstructTCOData,
|
|
BOOL bAdmin
|
|
)
|
|
{
|
|
// Want to log the security context, user must have administrative priviledge!
|
|
|
|
pDetailLogger->LogTCHAR(_T("---- Input Data ----\n"));
|
|
pDetailLogger->LogTCHAR(_T("Description: "));
|
|
pDetailLogger->LogTCHAR(pstructTCOData->m_lptstrLongDesc);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
|
|
pDetailLogger->LogTCHAR(_T("User Security Context: "));
|
|
if (bAdmin)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("Has administrative priviledge.\n"));
|
|
}
|
|
else
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("Does not have administrative priviledge.\n"));
|
|
}
|
|
|
|
|
|
pDetailLogger->LogTCHAR(_T("LoggerType: "));
|
|
pDetailLogger->LogTCHAR(pstructTCOData->m_lptstrLoggerMode);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogTCHAR(_T("Enable: "));
|
|
pDetailLogger->LogULONG(pstructTCOData->m_ulEnable);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogTCHAR(_T("EnableFlag: "));
|
|
pDetailLogger->LogULONG(pstructTCOData->m_ulEnableFlag);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogTCHAR(_T("EnableLevel: "));
|
|
pDetailLogger->LogULONG(pstructTCOData->m_ulEnableLevel);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogTCHAR(_T("Expected Result: "));
|
|
pDetailLogger->LogULONG(pstructTCOData->m_ulExpectedResult, true);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogTCHAR(_T("Trace Handle: "));
|
|
if (pstructTCOData->m_pTraceHandle == NULL)
|
|
{
|
|
pDetailLogger->LogULONG64(0, true);
|
|
}
|
|
else
|
|
{
|
|
pDetailLogger->LogULONG64(*pstructTCOData->m_pTraceHandle, true);
|
|
}
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogTCHAR(_T("Instance Name: "));
|
|
pDetailLogger->LogTCHAR(pstructTCOData->m_lptstrInstanceName);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
pDetailLogger->LogEventTraceProperties(pstructTCOData->m_pProps);
|
|
|
|
pDetailLogger->LogTCHAR(_T("Guids:"));
|
|
|
|
LPTSTR lptstrGuid;
|
|
|
|
if (pstructTCOData->m_pProps != 0)
|
|
{
|
|
for (int i = 0; i < pstructTCOData->m_nGuids; i++)
|
|
{
|
|
lptstrGuid = LPTSTRFromGuid(pstructTCOData->m_lpguidArray[i]);
|
|
pDetailLogger->LogTCHAR(lptstrGuid);
|
|
free (lptstrGuid);
|
|
lptstrGuid = NULL;
|
|
if (pstructTCOData->m_nGuids > 1
|
|
&& i < pstructTCOData->m_nGuids - 1)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(","));
|
|
}
|
|
}
|
|
}
|
|
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
pDetailLogger->Flush();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int LogDetailAfterCall
|
|
( CLogger *pDetailLogger,
|
|
TCOData *pstructTCOData,
|
|
PEVENT_TRACE_PROPERTIES *pProps,
|
|
ULONG ulResult,
|
|
LPTSTR lpstrReturnedError,
|
|
bool bValid,
|
|
BOOL bAdmin,
|
|
LPCTSTR lptstrBanner,
|
|
bool bPrintProps
|
|
)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("---- Returned Values ----\n"));
|
|
|
|
if (lptstrBanner)
|
|
{
|
|
pDetailLogger->LogTCHAR(lptstrBanner);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
}
|
|
|
|
if (!bAdmin && ulResult == ERROR_SUCCESS
|
|
&& ulResult == pstructTCOData->m_ulExpectedResult)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("Test: "));
|
|
pDetailLogger->LogTCHAR(pstructTCOData->m_lptstrShortDesc);
|
|
pDetailLogger->LogTCHAR(_T(" failed\n"));
|
|
pDetailLogger->LogTCHAR(_T("SecurityContextError: API should have failed because the user does not have administrative privledge.\n"));
|
|
}
|
|
else if (ulResult == pstructTCOData->m_ulExpectedResult)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("Test: "));
|
|
pDetailLogger->LogTCHAR(pstructTCOData->m_lptstrShortDesc);
|
|
pDetailLogger->LogTCHAR(_T(" passed\n"));
|
|
|
|
}
|
|
else
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("Test: "));
|
|
pDetailLogger->LogTCHAR(pstructTCOData->m_lptstrShortDesc);
|
|
pDetailLogger->LogTCHAR(_T(" failed\n"));
|
|
pDetailLogger->LogTCHAR(_T("Expected result: "));
|
|
pDetailLogger->LogULONG(pstructTCOData->m_ulExpectedResult, true);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
}
|
|
|
|
pDetailLogger->LogTCHAR(_T("Test result: "));
|
|
pDetailLogger->LogULONG(ulResult, true);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
if (ulResult && lpstrReturnedError)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("Error Description: "));
|
|
pDetailLogger->LogTCHAR(lpstrReturnedError);
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
}
|
|
|
|
pDetailLogger->LogTCHAR(_T("Trace Handle: "));
|
|
if (pstructTCOData->m_pTraceHandle == NULL)
|
|
{
|
|
pDetailLogger->LogULONG64(0, true);
|
|
}
|
|
else
|
|
{
|
|
pDetailLogger->LogULONG64(*pstructTCOData->m_pTraceHandle, true);
|
|
}
|
|
pDetailLogger->LogTCHAR(_T("\n"));
|
|
|
|
if (bPrintProps)
|
|
{
|
|
pDetailLogger->LogEventTraceProperties(*pProps);
|
|
pDetailLogger->LogTCHAR(_T("-------------------------------------------------------\n"));
|
|
|
|
}
|
|
|
|
pDetailLogger->Flush();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int LogSummaryBeforeCall
|
|
(
|
|
TCOData *pstructTCOData,
|
|
LPCTSTR lpctstrDataFile,
|
|
LPCTSTR lptstrAction,
|
|
LPCTSTR lptstrAPI,
|
|
bool bLogExpected
|
|
)
|
|
{
|
|
t_cout << _T("\n") << lptstrAPI << _T(" called with TCOTest = ")
|
|
<< pstructTCOData->m_lptstrShortDesc << _T("\n");
|
|
t_cout << _T("Action = ") << lptstrAction << _T("\n");
|
|
if (lpctstrDataFile)
|
|
{
|
|
t_cout << _T("DataFile = ") << lpctstrDataFile << _T("\n");
|
|
}
|
|
if (bLogExpected && pstructTCOData->m_lptstrLongDesc)
|
|
{
|
|
t_cout << _T("Description = ") << pstructTCOData->m_lptstrLongDesc << _T("\n");
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
int LogSummaryAfterCall
|
|
(
|
|
TCOData *pstructTCOData,
|
|
LPCTSTR lpctstrDataFile,
|
|
LPCTSTR lptstrAction,
|
|
ULONG ulActualResult,
|
|
LPTSTR lptstrErrorDesc,
|
|
bool bLogExpected
|
|
)
|
|
{
|
|
t_string tsOut1;
|
|
t_string tsOut2;
|
|
|
|
tsOut1 = ULONGVarToTString(ulActualResult, true);
|
|
tsOut2 = ULONGVarToTString(pstructTCOData->m_ulExpectedResult, true);
|
|
|
|
if (ulActualResult == pstructTCOData->m_ulExpectedResult && bLogExpected)
|
|
{
|
|
t_cout << pstructTCOData->m_lptstrShortDesc << _T(" - Passed: Actual result ");
|
|
t_cout << tsOut1 << _T(" = to expected result ") << tsOut2 << _T(".\n");
|
|
}
|
|
else if (ulActualResult != pstructTCOData->m_ulExpectedResult && bLogExpected)
|
|
{
|
|
t_cout << pstructTCOData->m_lptstrShortDesc << _T(" - Failed: Actual result ");
|
|
t_cout << tsOut1 << _T(" not = to expected result ") << tsOut2 << _T(".\n");
|
|
}
|
|
else if (ulActualResult == ERROR_SUCCESS && !bLogExpected)
|
|
{
|
|
t_cout << pstructTCOData->m_lptstrShortDesc << _T(" - Passed.\n");
|
|
}
|
|
else if (ulActualResult != ERROR_SUCCESS && !bLogExpected)
|
|
{
|
|
t_cout << pstructTCOData->m_lptstrShortDesc << _T(" - Failed.\n");
|
|
}
|
|
|
|
if (lptstrErrorDesc && ulActualResult != pstructTCOData->m_ulExpectedResult)
|
|
{
|
|
t_cout << _T("Error: ") << lptstrErrorDesc << _T("\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool LogPropsDiff
|
|
( CLogger *pDetailLogger,
|
|
PEVENT_TRACE_PROPERTIES pProps1,
|
|
PEVENT_TRACE_PROPERTIES pProps2
|
|
)
|
|
{
|
|
bool bDiff = false;
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T("EVENT_TRACE_PROPERTIES data items which differ:\n"));
|
|
pDetailLogger->Flush();
|
|
}
|
|
|
|
if (pProps1->BufferSize != pProps2->BufferSize)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" BufferSize\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->MinimumBuffers != pProps2->MinimumBuffers)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" MinimumBuffers\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->MaximumBuffers != pProps2->MaximumBuffers)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" MaximumBuffers\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->MaximumFileSize != pProps2->MaximumFileSize)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" MaximumFileSize\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->LogFileMode != pProps2->LogFileMode)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" LogFileMode\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->FlushTimer != pProps2->FlushTimer)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" FlushTimer\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->EnableFlags != pProps2->EnableFlags)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" EnableFlags\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (pProps1->AgeLimit != pProps2->AgeLimit)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" AgeLimit\n"));
|
|
}
|
|
bDiff = true;
|
|
}
|
|
|
|
if (!bDiff)
|
|
{
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->LogTCHAR(_T(" None\n"));
|
|
}
|
|
}
|
|
|
|
if (pDetailLogger)
|
|
{
|
|
pDetailLogger->Flush();
|
|
}
|
|
|
|
return bDiff;
|
|
}
|