1302 lines
45 KiB
C++
1302 lines
45 KiB
C++
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// BVTUtil.CPP
|
|
//
|
|
//
|
|
// Copyright (c)2000 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#include "bvt.h"
|
|
#include <time.h>
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
_CPropertyList::~_CPropertyList()
|
|
{
|
|
for( int i = 0; i < m_List.Size(); i++ )
|
|
{
|
|
PropertyInfo * pPtr = (PropertyInfo*)m_List[i];
|
|
delete pPtr;
|
|
}
|
|
m_List.Empty();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int _CPropertyList::PropertiesCompareAsExpectedAndLogErrors( WCHAR * wcsClass, WCHAR * wcsNamespace,
|
|
BOOL fExpectedFailure, const char * csFile, const ULONG Line)
|
|
{
|
|
int nRc = SUCCESS;
|
|
|
|
for( int i = 0; i < m_List.Size(); i++ )
|
|
{
|
|
PropertyInfo * pPtr = (PropertyInfo*)m_List[i];
|
|
if( !pPtr->fProcessed )
|
|
{
|
|
if( pPtr->QualifierName && pPtr->Property)
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Expected Property Qualifier %s on Property %s in class %s in namespace %s - but it wasn't there",pPtr->QualifierName, pPtr->Property, wcsClass, wcsNamespace);
|
|
}
|
|
else if( pPtr->Property )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Expected property %s in class in namespace %s - but it wasn't there",pPtr->Property, wcsClass, wcsNamespace);
|
|
}
|
|
else
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Expected property ??? in class in namespace %s - but it wasn't there",wcsClass, wcsNamespace);
|
|
}
|
|
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
return nRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int _CPropertyList::PropertyInListAndLogErrors(PropertyInfo * pProp, WCHAR * wcsClass, WCHAR * wcsNamespace,
|
|
BOOL fExpectedFailure, const char * csFile, const ULONG Line)
|
|
{
|
|
int nRc = FATAL_ERROR;
|
|
BOOL fLogged = FALSE;
|
|
|
|
for( int i = 0; i < m_List.Size(); i++ )
|
|
{
|
|
PropertyInfo * pPtr = (PropertyInfo*)m_List[i];
|
|
|
|
BOOL fContinue = FALSE;
|
|
if( pPtr->Property )
|
|
{
|
|
if( _wcsicmp( pPtr->Property, pProp->Property ) == 0 )
|
|
{
|
|
fContinue = TRUE;
|
|
}
|
|
}
|
|
else if( pPtr->QualifierName)
|
|
{
|
|
if( _wcsicmp( pPtr->QualifierName, pProp->QualifierName ) == 0 )
|
|
{
|
|
fContinue = TRUE;
|
|
}
|
|
}
|
|
if( fContinue )
|
|
{
|
|
if( pPtr->Type == pProp->Type )
|
|
{
|
|
if( CompareType(pPtr->Var,pProp->Var,pProp->Type) )
|
|
{
|
|
if( !pPtr->fProcessed )
|
|
{
|
|
nRc = SUCCESS;
|
|
pPtr->fProcessed = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
if( pPtr->QualifierName && pPtr->Property )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Property Qualifier %s for Property %s for Class %s for Namespace %s, showed up in the list twice.", pPtr->QualifierName, pPtr->Property, wcsClass, wcsNamespace);
|
|
}
|
|
else if( pPtr->Property )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Property showed up in the list twice. Property %s in Class %s in namespace %s", pPtr->Property, wcsClass, wcsNamespace);
|
|
}
|
|
else
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Property ???? showed up in the list twice. Property ??? for Class %s in namespace %s", wcsClass, wcsNamespace);
|
|
}
|
|
fLogged = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( nRc == FATAL_ERROR )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
if( !fLogged )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Did not find expected properties in class %s in namespace %s", wcsClass, wcsNamespace);
|
|
}
|
|
}
|
|
}
|
|
return nRc;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
_ItemList::~_ItemList()
|
|
{
|
|
for( int i = 0; i < m_List.Size(); i++ )
|
|
{
|
|
ItemInfo * pPtr = (ItemInfo*)m_List[i];
|
|
delete pPtr;
|
|
}
|
|
m_List.Empty();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int _ItemList::ItemsCompareAsExpectedAndLogErrors(WCHAR * wcsNamespace,
|
|
BOOL fExpectedFailure, const char * csFile, const ULONG Line)
|
|
{
|
|
int nRc = SUCCESS;
|
|
|
|
for( int i = 0; i < m_List.Size(); i++ )
|
|
{
|
|
ItemInfo * pPtr = (ItemInfo*)m_List[i];
|
|
if( !pPtr->fProcessed )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Expected class not in namespace. Class %s in namespace %s",pPtr->Item, wcsNamespace);
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
return nRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int _ItemList::ItemInListAndLogErrors(WCHAR * wcsClass, WCHAR * wcsNamespace,
|
|
BOOL fExpectedFailure, const char * csFile, const ULONG Line)
|
|
{
|
|
int nRc = FATAL_ERROR;
|
|
BOOL fLogged = FALSE;
|
|
|
|
for( int i = 0; i < m_List.Size(); i++ )
|
|
{
|
|
ItemInfo * pPtr = (ItemInfo*)m_List[i];
|
|
if( _wcsicmp(pPtr->Item,wcsClass ) == 0 )
|
|
{
|
|
if( !pPtr->fProcessed )
|
|
{
|
|
nRc = SUCCESS;
|
|
pPtr->fProcessed = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Class showed up in the list twice. Class %s in namespace %s", wcsClass, wcsNamespace);
|
|
fLogged = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( nRc == FATAL_ERROR )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
if( !fLogged )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Did not find expected class %s in namespace %s", wcsClass, wcsNamespace);
|
|
}
|
|
}
|
|
}
|
|
return nRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*****************************************************************************************************************
|
|
//
|
|
// The error logging and display class
|
|
//
|
|
//*****************************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CLogAndDisplayOnScreen::CLogAndDisplayOnScreen()
|
|
{
|
|
memset( m_wcsFileName,NULL,MAX_PATH+2);
|
|
m_fDisplay = TRUE;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CLogAndDisplayOnScreen::~CLogAndDisplayOnScreen()
|
|
{
|
|
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CLogAndDisplayOnScreen::WriteToFile(WCHAR * pwcsError, WCHAR * pwcsFileAndLine, const WCHAR *wcsString)
|
|
{
|
|
BOOL fRc = FALSE;
|
|
//===========================================
|
|
// Get time.
|
|
//===========================================
|
|
WCHAR wcsTime[MAX_PATH];
|
|
|
|
memset(wcsTime,NULL,MAX_PATH);
|
|
|
|
time_t now = time(0);
|
|
struct tm *local = localtime(&now);
|
|
if(local)
|
|
{
|
|
wcscpy(wcsTime, _wasctime(local));
|
|
}
|
|
else
|
|
{
|
|
wcscpy(wcsTime,L"??");
|
|
}
|
|
|
|
//===========================================
|
|
// Open the file and log the error
|
|
//===========================================
|
|
FILE * fp = _wfopen( m_wcsFileName, L"at");
|
|
if (fp)
|
|
{
|
|
fwprintf(fp, L"(%s) : %s - [%s]\n %s", wcsTime,pwcsError,pwcsFileAndLine, wcsString);
|
|
fRc = TRUE;
|
|
fclose(fp);
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CLogAndDisplayOnScreen::LogError(const char * csFile , const ULONG Line , int nErrorType, const WCHAR *fmt, ...)
|
|
{
|
|
BOOL fRc = FALSE;
|
|
CHString Buffer;
|
|
CHString FileAndLine;
|
|
WCHAR * pwcsWarning = L"WARNING";
|
|
WCHAR * pwcsFatal = L"FATAL";
|
|
WCHAR * pwcsSuccess = L"SUCCESS";
|
|
WCHAR * pwcsError = NULL;
|
|
WCHAR * pwcsFile = NULL;
|
|
|
|
CAutoBlock block(&m_CritSec);
|
|
|
|
//==================================================
|
|
// First of all, allocate and format the strings
|
|
// Get the type of error
|
|
//==================================================
|
|
if( nErrorType == FATAL_ERROR )
|
|
{
|
|
pwcsError = pwcsFatal;
|
|
}
|
|
else if( nErrorType == WARNING )
|
|
{
|
|
pwcsError = pwcsWarning;
|
|
}
|
|
else
|
|
{
|
|
pwcsError = pwcsSuccess;
|
|
}
|
|
|
|
if( S_OK == AllocateAndConvertAnsiToUnicode((char *)(const char*)csFile, pwcsFile))
|
|
{
|
|
if( FileAndLine.GetBuffer(wcslen(pwcsFile)+25))
|
|
{
|
|
//==============================================
|
|
// Create the filename and line number string
|
|
//==============================================
|
|
FileAndLine.Format(L"File:%s,Line: %d",pwcsFile,Line);
|
|
if( Buffer.GetBuffer(2048) )
|
|
{
|
|
va_list argptr;
|
|
int cnt = 0;
|
|
WCHAR * wcsPtr = (WCHAR*)((const WCHAR*)Buffer);
|
|
va_start(argptr, fmt);
|
|
|
|
cnt = _vsnwprintf(wcsPtr , 2047, fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
//==============================================
|
|
// a -1 indicates that the buffer was exceeded
|
|
//==============================================
|
|
if( cnt != -1 )
|
|
{
|
|
fRc = Log(pwcsError, (WCHAR*)((const WCHAR*)FileAndLine),(WCHAR*)((const WCHAR*) Buffer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !fRc )
|
|
{
|
|
wprintf(L"Major error, BVT cannot run\n");
|
|
}
|
|
|
|
SAFE_DELETE_ARRAY(pwcsFile);
|
|
return fRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*****************************************************************************************************************
|
|
//
|
|
// Misc. Functions
|
|
//
|
|
//*****************************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AllocateAndConvertAnsiToUnicode(char * pstr, WCHAR *& pszW)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
pszW = NULL;
|
|
|
|
int nSize = strlen(pstr);
|
|
if (nSize != 0 ){
|
|
|
|
// Determine number of wide characters to be allocated for the
|
|
// Unicode string.
|
|
nSize++;
|
|
pszW = new WCHAR[nSize * 2];
|
|
if (NULL != pszW)
|
|
{
|
|
// Covert to Unicode.
|
|
MultiByteToWideChar(CP_ACP, 0, pstr, nSize,pszW,nSize);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int ConvertType( CVARIANT & Var, long & lType, const WCHAR * wcsType, WCHAR * wcsValue )
|
|
{
|
|
int nRc = SUCCESS;
|
|
|
|
if (_wcsicmp(L"CIM_UINT8",wcsType) == 0 )
|
|
{
|
|
lType = CIM_UINT8;
|
|
Var.SetByte((BYTE)_wtoi(wcsValue));
|
|
}
|
|
else if (_wcsicmp(L"CIM_SINT8",wcsType) == 0 )
|
|
{
|
|
lType = CIM_SINT8;
|
|
Var.SetByte((BYTE)_wtoi(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_BOOLEAN",wcsType) == 0 )
|
|
{
|
|
lType = CIM_BOOLEAN;
|
|
Var.SetBool((SHORT)_wtoi(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_CHAR16",wcsType) == 0 )
|
|
{
|
|
lType = CIM_CHAR16;
|
|
Var.SetShort((SHORT)_wtoi(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_SINT16",wcsType) == 0 )
|
|
{
|
|
lType = CIM_SINT16;
|
|
Var.SetShort((SHORT)_wtoi(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_UINT16",wcsType) == 0 )
|
|
{
|
|
lType = CIM_UINT16;
|
|
Var.SetShort((SHORT)_wtoi(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_REAL32",wcsType) == 0 )
|
|
{
|
|
lType = CIM_REAL32;
|
|
|
|
// Var.SetLONG(_wtof(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_SINT32",wcsType) == 0 )
|
|
{
|
|
lType = CIM_SINT32;
|
|
Var.SetLONG(_wtol(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_UINT32",wcsType) == 0 )
|
|
{
|
|
lType = CIM_UINT32;
|
|
Var.SetLONG(_wtol(wcsValue));
|
|
}
|
|
else if( _wcsicmp(L"CIM_SINT64",wcsType) == 0 )
|
|
{
|
|
lType = CIM_SINT64;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else if( _wcsicmp(L"CIM_UINT64",wcsType) == 0 )
|
|
{
|
|
lType = CIM_UINT64;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else if( _wcsicmp(L"CIM_REAL64",wcsType) == 0 )
|
|
{
|
|
lType = CIM_REAL64;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else if( _wcsicmp(L"CIM_DATETIME",wcsType) == 0 )
|
|
{
|
|
lType = CIM_DATETIME;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else if( _wcsicmp(L"CIM_STRING",wcsType) == 0 )
|
|
{
|
|
lType = CIM_STRING;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else if( _wcsicmp(L"CIM_STRING|CIM_FLAG_ARRAY",wcsType) == 0 )
|
|
{
|
|
lType = CIM_STRING|CIM_FLAG_ARRAY;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else if( _wcsicmp(L"CIM_REFERENCE",wcsType) == 0 )
|
|
{
|
|
lType = CIM_REFERENCE;
|
|
Var.SetStr(wcsValue);
|
|
}
|
|
else
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CompareType( CVARIANT & Var1, CVARIANT & Var2, long lType )
|
|
{
|
|
BOOL fRc = FALSE;
|
|
|
|
switch( lType )
|
|
{
|
|
case CIM_UINT8:
|
|
case CIM_SINT8:
|
|
if( Var1.GetByte() == Var2.GetByte() )
|
|
{
|
|
fRc = TRUE;
|
|
}
|
|
break;
|
|
|
|
case CIM_BOOLEAN:
|
|
if( Var1.GetBool() == Var2.GetBool() )
|
|
{
|
|
fRc = TRUE;
|
|
}
|
|
break;
|
|
|
|
case CIM_CHAR16:
|
|
case CIM_SINT16:
|
|
case CIM_UINT16:
|
|
if( Var1.GetShort() == Var2.GetShort() )
|
|
{
|
|
fRc = TRUE;
|
|
}
|
|
break;
|
|
|
|
case CIM_SINT32:
|
|
case CIM_UINT32:
|
|
if( Var1.GetLONG() == Var2.GetLONG() )
|
|
{
|
|
fRc = TRUE;
|
|
}
|
|
break;
|
|
|
|
case CIM_SINT64:
|
|
case CIM_UINT64:
|
|
case CIM_REAL64:
|
|
case CIM_DATETIME:
|
|
case CIM_STRING:
|
|
case CIM_REFERENCE:
|
|
if( _wcsicmp(Var1.GetStr(), Var2.GetStr()) == 0 )
|
|
{
|
|
fRc = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return fRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL GetAndCrackClassName(WCHAR * wcsKey, int nWhichTest, BOOL fAction, ItemList & MasterList)
|
|
{
|
|
CHString sClassDefinition;
|
|
BOOL fRc = FALSE;
|
|
int nTest = 0;
|
|
CHString sClassDefinitionSection;
|
|
if( SUCCESS == GetClassDefinitionSection(nWhichTest, sClassDefinitionSection,nTest ))
|
|
{
|
|
//==========================================================
|
|
// Now, use the new test section we just got where the
|
|
// definition lives.
|
|
//==========================================================
|
|
if( g_Options.GetSpecificOptionForAPITest(wcsKey, sClassDefinition,nTest))
|
|
{
|
|
CHString sClass;
|
|
//===========================================================
|
|
// Get the class name
|
|
//===========================================================
|
|
int nRc = CrackClassName(sClassDefinition,sClass, NO_ERRORS_EXPECTED);
|
|
if( SUCCESS == nRc )
|
|
{
|
|
ItemInfo *p = new ItemInfo;
|
|
if( p )
|
|
{
|
|
p->fAction = fAction;
|
|
p->Item = sClass;
|
|
p->KeyName = wcsKey;
|
|
MasterList.Add(p);
|
|
fRc = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fRc = FALSE;
|
|
}
|
|
}
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
// "Delete:TestClass2, Delete:TestClass9, Add:TestClass2, Delete: TestClass7, Delete: TestClass6"
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL InitMasterListOfAddDeleteClasses(const WCHAR * wcsString,int nWhichTest, ItemList & MasterList)
|
|
{
|
|
BOOL fRc = FALSE;
|
|
WCHAR * wcsClassesAddDelete = (WCHAR*) wcsString;
|
|
|
|
WCHAR * wcsToken = wcstok( wcsClassesAddDelete,L":, ");
|
|
ItemList TempList;
|
|
|
|
//==============================================================
|
|
// Start looping through all of the classes
|
|
//==============================================================
|
|
while( wcsToken )
|
|
{
|
|
fRc = FALSE;
|
|
BOOL fAction;
|
|
//==========================================================
|
|
// If it is a class to be deleted
|
|
//==========================================================
|
|
if( _wcsicmp(L"Delete",wcsToken ) == 0 )
|
|
{
|
|
fAction = DELETE_CLASS;
|
|
}
|
|
else
|
|
{
|
|
fAction = ADD_CLASS;
|
|
}
|
|
wcsToken = wcstok( NULL, L":, ");
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
ItemInfo *p = new ItemInfo;
|
|
if( p )
|
|
{
|
|
p->fAction = fAction;
|
|
p->Item = wcsToken;
|
|
TempList.Add(p);
|
|
fRc = TRUE;
|
|
}
|
|
wcsToken = wcstok( NULL, L",: ");
|
|
}
|
|
|
|
if( fRc )
|
|
{
|
|
//==============================================================
|
|
// Start looping through all of the classes
|
|
//==============================================================
|
|
for( int i = 0; i < TempList.Size(); i++ )
|
|
{
|
|
ItemInfo * pClass = TempList.GetAt(i);
|
|
fRc = GetAndCrackClassName(WPTR pClass->Item,nWhichTest,pClass->fAction,MasterList);
|
|
if( !fRc )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return fRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
// { "TestClass1,TestClass3" },
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL InitAndExpandMasterList(const WCHAR * wcsClassesString, int nWhichTest, ItemList & MasterList)
|
|
{
|
|
BOOL fRc = FALSE;
|
|
|
|
ItemList TempList;
|
|
if( InitMasterList(wcsClassesString,TempList))
|
|
{
|
|
//==============================================================
|
|
// Start looping through all of the classes
|
|
//==============================================================
|
|
for( int i = 0; i < TempList.Size(); i++ )
|
|
{
|
|
ItemInfo * pClass = TempList.GetAt(i);
|
|
fRc = GetAndCrackClassName(WPTR pClass->Item,nWhichTest,0,MasterList);
|
|
if( !fRc )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return fRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
// { "TestClass1,TestClass3" },
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL InitMasterList(const WCHAR * wcsClassesString,ItemList & MasterList)
|
|
{
|
|
BOOL fRc = FALSE;
|
|
|
|
WCHAR * wcsClassesAfterDelete = (WCHAR*) wcsClassesString;
|
|
WCHAR * wcsToken = wcstok( wcsClassesAfterDelete,L", ");
|
|
//==============================================================
|
|
// Start looping through all of the classes
|
|
//==============================================================
|
|
while( wcsToken )
|
|
{
|
|
fRc = FALSE;
|
|
|
|
ItemInfo *p = new ItemInfo;
|
|
if( !p )
|
|
{
|
|
break;
|
|
}
|
|
p->Item = wcsToken;
|
|
|
|
MasterList.Add(p);
|
|
fRc = TRUE;
|
|
|
|
wcsToken = wcstok( NULL, L",: ");
|
|
}
|
|
|
|
return fRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Just get the class name
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackClassName( const WCHAR * wcsString, CHString & sClass, BOOL fExpectedFailure, const char * csFile, const ULONG Line )
|
|
{
|
|
int nRc = FATAL_ERROR;
|
|
WCHAR wcsSeps[] = L":, ";
|
|
|
|
//=================================================================
|
|
// Set it on the first property before looping
|
|
//=================================================================
|
|
WCHAR * wcsClassString = (WCHAR *)wcsString;
|
|
WCHAR * wcsToken = wcstok( wcsClassString,wcsSeps);
|
|
|
|
//==============================================================
|
|
// Just get the class
|
|
//==============================================================
|
|
while(wcsToken )
|
|
{
|
|
if( ( _wcsicmp(wcsToken, L"Class") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( wcsToken )
|
|
{
|
|
sClass = wcsToken;
|
|
nRc = SUCCESS;
|
|
}
|
|
break;
|
|
}
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
}
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack the class name for this string: %s", wcsClassString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Property:FirstPoint:CIM_REFERENCE:Value, PropertyQualifier:CIMTYPE:CIM_STRING:ref:Test1, Property:EndPoint:CIM_REFERENCE:Value, PropertyQualifier:CIMTYPE:CIM_STRING:ref:Test2
|
|
// PropertyQualifier:QualifierName:PropertyName:KeyName3:CIM_SINT32:3, Property:PropertyName3:CIM_UINT32:3, Property:PropertyName3B:CIM_STRING:Test" },
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackProperties( WCHAR * wcsToken, CPropertyList & Properties, CHString & sClass, CHString & sParent, CHString & sInstance, int & Results )
|
|
{
|
|
int nRc = SUCCESS;
|
|
WCHAR wcsSeps[] = L":, ";
|
|
|
|
//==============================================================
|
|
// Process all of the properties and qualifiers
|
|
//==============================================================
|
|
while( wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
|
|
//==========================================================
|
|
// Find out if it is the parent class or instance name or
|
|
// class
|
|
//==========================================================
|
|
if( ( _wcsicmp(wcsToken, L"Parent") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
sParent = wcsToken;
|
|
nRc = SUCCESS;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"InstanceName") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,L"$");
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
sInstance = wcsToken;
|
|
//=======================================================
|
|
// Now, strip out the end of the instance name
|
|
//=======================================================
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
nRc = SUCCESS;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"Class") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
sClass = wcsToken;
|
|
nRc = SUCCESS;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"RESULTS") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
Results = _wtoi(wcsToken);
|
|
nRc = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
PropertyInfo *p = new PropertyInfo;
|
|
if( !p )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//==========================================================
|
|
// Find out if it is a key
|
|
//==========================================================
|
|
if( ( _wcsicmp(wcsToken, L"PropertyQualifier") == 0 ))
|
|
{
|
|
//==================================================
|
|
// If it is a qualifier, get the qualifier name
|
|
//==================================================
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
p->QualifierName = wcsToken;
|
|
}
|
|
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
//==========================================================
|
|
// Get the name of the property
|
|
//==========================================================
|
|
p->Property = wcsToken;
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
//==========================================================
|
|
// Get the type of the property or qualifier
|
|
//==========================================================
|
|
WCHAR * wcsType = wcsToken;
|
|
|
|
wcsToken = wcstok( NULL,L","); //note, now go to the next comma, as some string values may have embedded :
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//==========================================================
|
|
// Get the value
|
|
//==========================================================
|
|
nRc = ConvertType(p->Var, p->Type, wcsType, wcsToken );
|
|
if( nRc == SUCCESS )
|
|
{
|
|
Properties.Add(p);
|
|
}
|
|
}
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return nRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack: ( Note, there can be more than one key and more than one property )
|
|
//
|
|
// "Property:FirstPoint:CIM_REFERENCE:Value, PropertyQualifier:CIMTYPE:CIM_STRING:ref:Test1, Property:EndPoint:CIM_REFERENCE:Value, PropertyQualifier:CIMTYPE:CIM_STRING:ref:Test2
|
|
// "AssocProp1:Prop1:TestClass3, Prop2:AssocProp2:TestClass4"
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackAssociation( const WCHAR * wcsString, CHString & sClass, CPropertyList & Properties, int & nResults, BOOL fExpectedFailure, const char * csFile, const ULONG Line )
|
|
{
|
|
int nRc = SUCCESS;
|
|
WCHAR wcsSeps[] = L":, ";
|
|
|
|
//=================================================================
|
|
// Set it on the first property before looping
|
|
//=================================================================
|
|
WCHAR * wcsClassString = (WCHAR *)wcsString;
|
|
WCHAR * wcsToken = wcstok( wcsClassString,wcsSeps);
|
|
CHString sParent;
|
|
CHString sInstance;
|
|
|
|
nRc = CrackProperties(wcsToken, Properties, sClass, sParent, sInstance, nResults );
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack the association info for this string: %s", wcsClassString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
//
|
|
// L"CLASS:TestClass1, RESULTS:5"
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackClassNameAndResults(WCHAR * wcsInString, CHString & sClass, ItemList & Results, BOOL fExpectedFailure, const char * csFile, const ULONG Line )
|
|
{
|
|
int nRc = FATAL_ERROR;
|
|
|
|
WCHAR * wcsSeps = L",: ";
|
|
|
|
WCHAR * wcsToken = wcstok( wcsInString,wcsSeps);
|
|
|
|
if( ( _wcsicmp(wcsToken, L"Empty") == 0 ))
|
|
{
|
|
nRc = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
nRc = SUCCESS;
|
|
|
|
while( wcsToken )
|
|
{
|
|
//==============================================================
|
|
// See if we are dealing with CLASS or RESULTS
|
|
//==============================================================
|
|
if( ( _wcsicmp(wcsToken, L"CLASS") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
sClass = wcsToken;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"RESULTS") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
ItemInfo * p = new ItemInfo;
|
|
if( p )
|
|
{
|
|
p->Results = _wtoi(wcsToken);
|
|
Results.Add(p);
|
|
nRc = SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
//==============================================================
|
|
// Get the next string
|
|
//==============================================================
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
}
|
|
}
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack Class and Results info for this string: %s", wcsInString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
//
|
|
// { L"1", L"CLASS:TestClass1, METHOD:TestMethd, INPUT:Property:InputArg1:CIM_UINT32:555, OUTPUT:Property:OutputArg1:CIM_UINT32:111"}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackMethod(WCHAR * wcsInString, CHString & sClass, CHString & sInst, CHString & sMethod,CPropertyList & InProps,
|
|
CPropertyList & OutProps,int & nResults, BOOL fExpectedFailure, const char * csFile, const ULONG Line )
|
|
{
|
|
|
|
int nRc = FATAL_ERROR;
|
|
|
|
WCHAR * wcsSeps = L",: ";
|
|
|
|
WCHAR * wcsToken = wcstok( wcsInString,wcsSeps);
|
|
|
|
if( ( _wcsicmp(wcsToken, L"Empty") == 0 ))
|
|
{
|
|
nRc = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
nRc = SUCCESS;
|
|
|
|
while( wcsToken )
|
|
{
|
|
//==============================================================
|
|
// See if we are dealing with CLASS, METHOD, INPUT_CLASS
|
|
// OUTPUT_CLASS
|
|
//==============================================================
|
|
if( ( _wcsicmp(wcsToken, L"CLASS") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
sClass = wcsToken;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"InstanceName") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,L"$");
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
sInst = wcsToken;
|
|
//=======================================================
|
|
// Now, strip out the end of the instance name
|
|
//=======================================================
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
nRc = SUCCESS;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"RESULTS") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
nResults = _wtoi(wcsToken);
|
|
nRc = SUCCESS;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"METHOD") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
sMethod = wcsToken;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"INPUT") == 0 ) || ( _wcsicmp(wcsToken, L"OUTPUT") == 0 ))
|
|
{
|
|
PropertyInfo *p = new PropertyInfo;
|
|
if( !p )
|
|
{
|
|
break;
|
|
}
|
|
|
|
BOOL fOutput = FALSE;
|
|
if( _wcsicmp(wcsToken, L"OUTPUT") == 0 )
|
|
{
|
|
fOutput = TRUE;
|
|
}
|
|
|
|
//==========================================================
|
|
// Find out if it is a qualifier
|
|
//==========================================================
|
|
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
if( ( _wcsicmp(wcsToken, L"PropertyQualifier") == 0 ))
|
|
{
|
|
//==================================================
|
|
// If it is a qualifier, get the qualifier name
|
|
//==================================================
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
p->QualifierName = wcsToken;
|
|
}
|
|
//==========================================================
|
|
// Get the name of the property
|
|
//==========================================================
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
p->Property = wcsToken;
|
|
//==========================================================
|
|
// Get the type of the property or qualifier
|
|
//==========================================================
|
|
wcsToken = wcstok( NULL,wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
WCHAR * wcsType = wcsToken;
|
|
//==========================================================
|
|
// Get the value
|
|
//==========================================================
|
|
wcsToken = wcstok( NULL,L" ,"); //note, now go to the next comma, as some string values may have embedded :
|
|
if( !wcsToken )
|
|
{
|
|
break;
|
|
}
|
|
nRc = ConvertType(p->Var, p->Type, wcsType, wcsToken );
|
|
if( nRc == SUCCESS )
|
|
{
|
|
if( fOutput )
|
|
{
|
|
OutProps.Add(p);
|
|
}
|
|
else
|
|
{
|
|
InProps.Add(p);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
//==============================================================
|
|
// Get the next string
|
|
//==============================================================
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
}
|
|
}
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack Method info for this string: %s", wcsInString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
//
|
|
// { L"NAMESPACE_CREATION", L"LANGUAGE:WQL, QUERY:select * from __NamespaceCreationEvent, TYPE:NAMESPACE, EXECUTE_SECTION: APITEST4, RESULTS:4,NAMESPACE:ROOT"}
|
|
// { L"INSTANCE_CREATION", L"LANGUAGE:WQL, QUERY:select * from __InstanceCreationEvent, TYPE:INSTANCE, EXECUTE_SECTION: APITEST9, RESULTS:4,NAMESPACE:ROOT},
|
|
// { L"CLASS_CREATION", L"LANGUAGE:WQL, QUERY:select * from __ClassCreationEvent, TYPE:CLASS, EXECUTE_SECTION: APITEST5, RESULTS:4,NAMESPACE:ROOT}};
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackEvent(WCHAR * wcsInEventString, EventInfo & Event, BOOL fExpectedFailure, const char * csFile, const ULONG Line )
|
|
{
|
|
|
|
int nRc = FATAL_ERROR;
|
|
|
|
WCHAR * wcsSeps = L",: ";
|
|
|
|
WCHAR * wcsToken = wcstok( wcsInEventString,wcsSeps);
|
|
|
|
if( ( _wcsicmp(wcsToken, L"Empty") == 0 ))
|
|
{
|
|
nRc = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
nRc = SUCCESS;
|
|
|
|
while( wcsToken )
|
|
{
|
|
//==============================================================
|
|
// See if we are dealing with LANGUAGE, QUERY, TYPE or
|
|
// EXECUTE_SECTION
|
|
//==============================================================
|
|
if( ( _wcsicmp(wcsToken, L"LANGUAGE") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
Event.Language = wcsToken;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"QUERY") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL,L"\"");
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
|
|
Event.Query = wcsToken;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"EXECUTE_SECTION") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
Event.Section = _wtoi(wcsToken);
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"NAMESPACE") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
Event.Namespace = wcsToken;
|
|
}
|
|
else if( ( _wcsicmp(wcsToken, L"RESULTS") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( !wcsToken )
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
Event.Results = _wtoi(wcsToken);
|
|
}
|
|
else
|
|
{
|
|
nRc = FATAL_ERROR;
|
|
break;
|
|
}
|
|
//==============================================================
|
|
// Get the next string
|
|
//==============================================================
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
}
|
|
}
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack Event info for this string: %s", wcsInEventString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack:
|
|
//
|
|
// L"NAMESPACE:ROOT\\WMI"},
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackNamespace(WCHAR * wcsInString, CHString & sNamespace, BOOL fExpectedFailure,const char * csFile, const ULONG Line )
|
|
{
|
|
int nRc = FATAL_ERROR;
|
|
|
|
WCHAR * wcsSeps = L",: ";
|
|
|
|
WCHAR * wcsToken = wcstok( wcsInString,wcsSeps);
|
|
|
|
if( ( _wcsicmp(wcsToken, L"Empty") == 0 ))
|
|
{
|
|
nRc = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
if( ( _wcsicmp(wcsToken, L"NAMESPACE") == 0 ))
|
|
{
|
|
wcsToken = wcstok( NULL, wcsSeps);
|
|
if( wcsToken )
|
|
{
|
|
sNamespace = wcsToken;
|
|
nRc = SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack namespace info for this string: %s", wcsInString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Format to crack: ( Note, there can be more than one key and more than one property )
|
|
//
|
|
// TestClass10= "Parent:TestClass9,Key:KeyName10:CIM_UINT32:10, Property:PropertyName10:CIM_BOOLEAN:0"
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CrackClass(WCHAR * wcsInClassString, CHString & sClass, CHString & sParentClass, CHString & sInstance,
|
|
CPropertyList & Properties, int & nResults, BOOL fExpectedFailure,const char * csFile, const ULONG Line )
|
|
{
|
|
int nRc = FATAL_ERROR;
|
|
|
|
WCHAR * wcsClassString = wcsInClassString;
|
|
WCHAR * wcsSeps = L",: ";
|
|
|
|
WCHAR * wcsToken = wcstok( wcsClassString,wcsSeps);
|
|
|
|
if( ( _wcsicmp(wcsToken, L"Empty") == 0 ))
|
|
{
|
|
nRc = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
nRc = CrackProperties(wcsToken, Properties, sClass, sParentClass, sInstance, nResults );
|
|
}
|
|
|
|
if( nRc != SUCCESS )
|
|
{
|
|
if( !fExpectedFailure )
|
|
{
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, L"Invalid ini entry, couldn't crack class info for this string: %s", wcsClassString );
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void LogCLSID(const char * csFile, const ULONG Line, WCHAR * wcsID, CLSID clsid)
|
|
{
|
|
LPOLESTR pStr = NULL;
|
|
|
|
if (SUCCEEDED(StringFromCLSID (clsid, &pStr)))
|
|
{
|
|
WCHAR wcsBuffer[MAX_PATH];
|
|
wsprintf(wcsBuffer,L"%s:%s",wcsID,pStr);
|
|
gp_LogFile->LogError(csFile,Line,FATAL_ERROR, wcsBuffer );
|
|
CoTaskMemFree (pStr);
|
|
}
|
|
}
|
|
|