//=============================================================================
// Code for loading and refreshing version 5.0 extensions.
//=============================================================================
#include "stdafx.h"
#include "category.h"
#include "dataset.h"
#include "wmiabstraction.h"
#include "version5extension.h"
CMapExtensionRefreshData gmapExtensionRefreshData;
extern HRESULT ChangeWBEMSecurity(IUnknown * pUnknown);
//-----------------------------------------------------------------------------
// Load the specified template from the named extension. This will involve
// loading the DLL and using the entry point to retrieve the text for the
// extension's template.
//
// Once the data is loaded, it's parsed into version 5 format structures.
//-----------------------------------------------------------------------------
typedef DWORD (__cdecl *pfuncGetTemplate)(void ** ppBuffer);
DWORD CTemplateFileFunctions::ParseTemplateIntoVersion5Categories(const CString & strExtension, CMapWordToPtr & mapVersion5Categories)
{
DWORD dwRootID = 0;
HINSTANCE hinst = LoadLibrary(strExtension);
if (hinst == NULL)
return dwRootID;
pfuncGetTemplate pfunc = (pfuncGetTemplate) GetProcAddress(hinst, "GetTemplate");
if (pfunc == NULL)
{
FreeLibrary(hinst);
return dwRootID;
}
// Call the DLL function with a NULL parameter to get the size of the buffer.
void * pBuffer;
CMemFile memfile;
DWORD dwBufferSize = (*pfunc)((void **)&pBuffer);
if (dwBufferSize && pBuffer)
{
memfile.Attach((BYTE *)pBuffer, dwBufferSize, 0);
dwRootID = ReadTemplateFile(&memfile, mapVersion5Categories);
memfile.Detach();
(void)(*pfunc)(NULL); // calling the exported DLL function with NULL frees its buffers
}
if (hinst != NULL)
FreeLibrary(hinst);
return dwRootID;
}
//-----------------------------------------------------------------------------
// This function reads the contents of a template file (in this case, a memory
// file) and produces a map of ID, INTERNAL_CATEGORY pointer pairs. It returns
// the ID for the root node in the tree.
//-----------------------------------------------------------------------------
DWORD CTemplateFileFunctions::ReadTemplateFile(CFile * pFile, CMapWordToPtr & mapVersion5Categories)
{
ASSERT(pFile);
if (pFile == NULL || !VerifyUNICODEFile(pFile) || !ReadHeaderInfo(pFile))
return 0;
return (ReadNodeRecursive(pFile, mapVersion5Categories, 0, 0));
}
//-----------------------------------------------------------------------------
// Make sure this is an MSInfo template file.
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::ReadHeaderInfo(CFile * pFile)
{
return VerifyAndAdvanceFile(pFile, CString(_T(TEMPLATE_FILE_TAG)));
}
//-----------------------------------------------------------------------------
// This method verifies that the passed file is a UNICODE file, by reading the
// value 0xFEFF from the file. It also leaves the file pointer past this word.
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::VerifyUNICODEFile(CFile * pFile)
{
WORD verify;
if (pFile->Read((void *) &verify, sizeof(WORD)) != sizeof(WORD))
return FALSE;
return (verify == 0xFEFF);
}
//-----------------------------------------------------------------------------
// This method verifies that the text in strVerify comes next in the file (not
// including case or whitespace differences) and advances the file past that
// text. If the text was the next content in the file, TRUE is returned,
// otherwise FALSE. If FALSE is returned, the file is backed up to where it
// was when this method was called.
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::VerifyAndAdvanceFile(CFile * pFile, const CString & strVerify)
{
DWORD dwPosition = pFile->GetPosition();
WCHAR cLastChar, cCurrentChar = L'\0';
BOOL fInComment = FALSE;
int iCharIndex = 0, iStringLen = strVerify.GetLength();
while (iCharIndex < iStringLen)
{
// Save the last character read, since the comment token ("//") is
// two characters long.
cLastChar = cCurrentChar;
// Read the next character in the file.
if (pFile->Read((void *) &cCurrentChar, sizeof(WCHAR)) != sizeof(WCHAR))
return FALSE;
// If we're in a comment, and the character we just read isn't a new line,
// we want to ignore it.
if (fInComment)
{
if (cCurrentChar == L'\n')
fInComment = FALSE;
continue;
}
// Check to see if we've started into a comment. Note that we ignore
// the first '/' also by continuing.
if (cCurrentChar == L'/')
{
if (cLastChar == L'/')
fInComment = TRUE;
continue;
}
// Skip whitespace, and also leading commas.
if (iswspace(cCurrentChar) || (cCurrentChar == L',' && iCharIndex == 0))
continue;
if (cCurrentChar != (WCHAR)strVerify[iCharIndex])
{
pFile->Seek((LONG)dwPosition, CFile::begin);
return FALSE;
}
iCharIndex++;
}
return TRUE;
}
//-----------------------------------------------------------------------------
// This is the recursive function to read a node. It reads the information
// from the node parameters, creates the node, and processes the contents of
// the block following the node (contained within "{}"'s). It's called
// recursively if there are any nodes in that block.
//
// In this version (for 6.0), it returns the ID of the node it's read.
//-----------------------------------------------------------------------------
DWORD CTemplateFileFunctions::ReadNodeRecursive(CFile * pFile, CMapWordToPtr & mapCategories, DWORD dwParentID, DWORD dwPrevID)
{
// Determine if we need to create a new category for this node. Read the
// information from the file to determine the identifier for the new category.
CString strEnumerateClass, strIdentifier;
if (!VerifyAndAdvanceFile(pFile, CString(NODE_KEYWORD) + CString("(")))
return 0;
if (!ReadArgument(pFile, strEnumerateClass))
return 0;
if (!ReadArgument(pFile, strIdentifier))
return 0;
// Generate the ID for this new node. This should be one greater than the max in the
// map (or one, if the map is empty).
DWORD dwID = 0;
WORD wMapID;
void * pDontCare;
for (POSITION pos = mapCategories.GetStartPosition(); pos != NULL;)
{
mapCategories.GetNextAssoc(pos, wMapID, pDontCare);
if ((DWORD) wMapID > dwID)
dwID = (DWORD) wMapID;
}
dwID += 1;
// Create the category for the node.
INTERNAL_CATEGORY * pCategory = CreateCategory(mapCategories, dwID, dwParentID, dwPrevID);
// Read the contents of the node argument list ("node(enum, identifier, field(source, formatstr, arg...))")
// We've already read up to and including the identifier.
pCategory->m_strEnumerateClass = strEnumerateClass;
pCategory->m_strIdentifier = strIdentifier;
if (!ReadField(pFile, pCategory->m_fieldName))
return 0;
// Copy the field name to the name of the category (they are two different
// member variables to allow for dynamically refreshed names, which turns
// out to be unnecessary in this version).
pCategory->m_categoryName.m_strText = pCategory->m_fieldName.m_strFormat;
if (!ReadArgument(pFile, pCategory->m_strNoInstances))
return 0;
if (!VerifyAndAdvanceFile(pFile, CString("){")))
return 0;
// Process the contents of the block (enclosed in "{}") for this node.
DWORD dwSubNodePrev = 0, dwNewNode = 0;
CString strKeyword;
// If this new category isn't actually new (i.e. it is being read from a
// template and overlaps an existing category) see if there are any
// existing children.
//
// Version 6.0: these are being read into distinct trees, so there should
// be no overlap (it would be resolved later).
while (GetKeyword(pFile, strKeyword))
{
if (strKeyword.CompareNoCase(CString(NODE_KEYWORD)) == 0)
{
dwNewNode = ReadNodeRecursive(pFile, mapCategories, dwID, dwSubNodePrev);
if (dwNewNode == 0)
return 0;
// If this is the first child node we've read, save its ID.
if (pCategory->m_dwChildID == 0)
pCategory->m_dwChildID = dwNewNode;
// If we've read another child node, set its next field appropriately.
if (dwSubNodePrev)
{
INTERNAL_CATEGORY * pPrevCategory = GetInternalRep(mapCategories, dwSubNodePrev);
if (pPrevCategory)
pPrevCategory->m_dwNextID = dwNewNode;
}
dwSubNodePrev = dwNewNode;
}
else if (strKeyword.CompareNoCase(CString(COLUMN_KEYWORD)) == 0)
{
if (!ReadColumnInfo(pFile, mapCategories, dwID))
return 0;
}
else if (strKeyword.CompareNoCase(CString(LINE_KEYWORD)) == 0)
{
GATH_LINESPEC * pNewLineSpec = ReadLineInfo(pFile);
if (pNewLineSpec == NULL)
return 0;
// Add the line we just read in to the end of the list of line specs for this
// internal category.
if (pCategory->m_pLineSpec == NULL)
pCategory->m_pLineSpec = pNewLineSpec;
else
{
GATH_LINESPEC * pLineSpec = pCategory->m_pLineSpec;
while (pLineSpec->m_pNext)
pLineSpec = pLineSpec->m_pNext;
pLineSpec->m_pNext = pNewLineSpec;
}
}
else if (strKeyword.CompareNoCase(CString(ENUMLINE_KEYWORD)) == 0)
{
GATH_LINESPEC * pNewLineSpec = ReadLineEnumRecursive(pFile, mapCategories);
if (pNewLineSpec == NULL)
return 0;
// Add the line we just read in to the end of the list of line specs for this
// internal category.
if (pCategory->m_pLineSpec == NULL)
pCategory->m_pLineSpec = pNewLineSpec;
else
{
GATH_LINESPEC * pLineSpec = pCategory->m_pLineSpec;
while (pLineSpec->m_pNext)
pLineSpec = pLineSpec->m_pNext;
pLineSpec->m_pNext = pNewLineSpec;
}
}
else
{
ASSERT(FALSE);
VerifyAndAdvanceFile(pFile, strKeyword);
}
}
if (!VerifyAndAdvanceFile(pFile, CString("}")))
return 0;
return dwID;
}
//-----------------------------------------------------------------------------
// Get the category structure, given a DWORD ID.
//-----------------------------------------------------------------------------
INTERNAL_CATEGORY * CTemplateFileFunctions::GetInternalRep(CMapWordToPtr & mapCategories, DWORD dwID)
{
INTERNAL_CATEGORY * pReturn;
if (mapCategories.Lookup((WORD) dwID, (void * &) pReturn))
return pReturn;
return NULL;
}
//-----------------------------------------------------------------------------
// Create the internal category structure.
//
// Version 6.0: this doesn't set the category ID.
//-----------------------------------------------------------------------------
INTERNAL_CATEGORY * CTemplateFileFunctions::CreateCategory(CMapWordToPtr & mapCategories, DWORD dwNewID, DWORD dwParentID, DWORD dwPrevID)
{
INTERNAL_CATEGORY * pInternalCat;
INTERNAL_CATEGORY * pPreviousCat;
CString strName;
pInternalCat = new INTERNAL_CATEGORY;
if (!pInternalCat)
return NULL;
pInternalCat->m_dwID = dwNewID;
pInternalCat->m_fListView = TRUE;
pInternalCat->m_dwParentID = dwParentID;
pInternalCat->m_dwPrevID = dwPrevID;
if (dwPrevID)
{
pPreviousCat = GetInternalRep(mapCategories, dwPrevID);
if (pPreviousCat)
pPreviousCat->m_dwNextID = dwNewID;
}
mapCategories.SetAt((WORD)dwNewID, (void *) pInternalCat);
return pInternalCat;
}
//-----------------------------------------------------------------------------
// This method simply reads an argument (as string) from the file, until a
// punctuation or whitespace character is found. If a quote mark is found,
// all characters are included in the string until another quote is found.
// NOTE: currently no way to have a quote mark in the string.
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::ReadArgument(CFile * pFile, CString & strSource)
{
BOOL fInQuote = FALSE, fInComment = FALSE;
CString strTemp;
WCHAR cLastChar, cCurrentChar = L'\0';
// Skip over characters until we reach an alphanumeric char. If we find
// a close paren, then we've reached the end of the argument list and
// should return FALSE.
do
{
// Save the last character read, since the comment token ("//") is
// two characters long.
cLastChar = cCurrentChar;
// Read the next character in the file.
if (pFile->Read((void *) &cCurrentChar, sizeof(WCHAR)) != sizeof(WCHAR))
return FALSE;
// If we're in a comment, and the character we just read isn't a new line,
// we want to ignore it.
if (fInComment)
{
if (cCurrentChar == L'\n')
fInComment = FALSE;
continue;
}
// Check to see if we've started into a comment.
if (cCurrentChar == L'/')
{
if (cLastChar == L'/')
fInComment = TRUE;
continue;
}
if (cCurrentChar == L')')
return FALSE;
} while (!iswalnum(cCurrentChar) && cCurrentChar != L'"');
// Read characters into the string until we find whitespace or punctuation.
do
{
if (cCurrentChar == L'"')
{
fInQuote = !fInQuote;
continue;
}
if (iswalnum(cCurrentChar) || fInQuote)
{
char strt[5] = "";
BOOL used = FALSE;
#ifdef UNICODE
strTemp += (TCHAR) cCurrentChar;
#else
WideCharToMultiByte(CP_ACP, 0, &cCurrentChar, 1, strt, 2, "?", &used);
strTemp += strt;
#endif
}
else
{
break;
}
} while (pFile->Read((void *) &cCurrentChar, sizeof(WCHAR)) == sizeof(WCHAR));
// If the last character read (the one which terminated this argument) was
// not a comma, then back the file up so that the character can be re-read
// and interpreted.
if (cCurrentChar != L',')
pFile->Seek(-(LONG)sizeof(WCHAR), CFile::current);
strSource = strTemp;
return TRUE;
}
//-----------------------------------------------------------------------------
// A field consists of a source string, followed by a format string, followed
// by a list of zero or more arguments.
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::ReadField(CFile * pFile, GATH_FIELD & field)
{
// Advance past the field keyword and read the two source and format strings.
if (!VerifyAndAdvanceFile(pFile, CString(FIELD_KEYWORD) + CString("(")))
return FALSE;
if (!ReadArgument(pFile, field.m_strSource))
return FALSE;
if (!ReadArgument(pFile, field.m_strFormat))
return FALSE;
// Read arguments until there are no more, building them into a list of
// arguments stored by the FIELD struct.
GATH_VALUE arg;
GATH_VALUE * pArg = NULL;
while (ReadArgument(pFile, arg.m_strText))
{
if (pArg == NULL)
{
field.m_pArgs = new GATH_VALUE;
if (field.m_pArgs == NULL)
return FALSE;
*field.m_pArgs = arg;
pArg = field.m_pArgs;
}
else
{
pArg->m_pNext = new GATH_VALUE;
if (pArg->m_pNext == NULL)
return FALSE;
*pArg->m_pNext = arg;
pArg = pArg->m_pNext;
}
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Read an enumline(){} block. This construct is used to group lines together
// which are enumerated for each instance of a class. A line is added to
// the parent node's list of lines with a m_strEnumerateClass equal to the
// class to be enumerated. The added line structure will have children lines
// (the lines to be enumerated) referenced by m_pEnumeratedGroup.
//-----------------------------------------------------------------------------
GATH_LINESPEC * CTemplateFileFunctions::ReadLineEnumRecursive(CFile * pFile, CMapWordToPtr & mapCategories)
{
if (!VerifyAndAdvanceFile(pFile, CString(ENUMLINE_KEYWORD) + CString("(")))
return NULL;
// Declare a line specification variable to store the line info.
GATH_LINESPEC * pNewLineSpec = new GATH_LINESPEC;
if (pNewLineSpec == NULL)
return NULL;
// Read in the enumerated class variable.
if (!ReadArgument(pFile, pNewLineSpec->m_strEnumerateClass))
{
delete pNewLineSpec;
return NULL;
}
// Read in the variable (zero or more) number of fields for the constraints.
GATH_FIELD * pNewField = new GATH_FIELD;
if (pNewField == NULL)
return NULL;
while (ReadField(pFile, *pNewField))
{
if (pNewLineSpec->m_pConstraintFields == NULL)
pNewLineSpec->m_pConstraintFields = pNewField;
else
{
// Add the newly read field to the end of the field list. Note,
// this is inefficient, and should be fixed. (NOTE)
GATH_FIELD * pFieldScan = pNewLineSpec->m_pConstraintFields;
while (pFieldScan->m_pNext)
pFieldScan = pFieldScan->m_pNext;
pFieldScan->m_pNext = pNewField;
}
pNewField = new GATH_FIELD;
if (pNewField == NULL)
return NULL;
}
delete pNewField;
// Advance past the close paren and the (necessary) open bracket.
if (!VerifyAndAdvanceFile(pFile, CString("){")))
{
delete pNewLineSpec;
return NULL;
}
// Read the contents of the block (should be all lines or enumlines).
CString strKeyword;
while (GetKeyword(pFile, strKeyword))
{
if (strKeyword.CompareNoCase(CString(LINE_KEYWORD)) == 0)
{
GATH_LINESPEC * pNewSubLine = ReadLineInfo(pFile);
if (pNewSubLine == NULL)
{
delete pNewLineSpec;
return NULL;
}
if (pNewLineSpec->m_pEnumeratedGroup == NULL)
pNewLineSpec->m_pEnumeratedGroup = pNewSubLine;
else
{
GATH_LINESPEC * pLineSpec = pNewLineSpec->m_pEnumeratedGroup;
while (pLineSpec->m_pNext)
pLineSpec = pLineSpec->m_pNext;
pLineSpec->m_pNext = pNewSubLine;
}
}
else if (strKeyword.CompareNoCase(CString(ENUMLINE_KEYWORD)) == 0)
{
GATH_LINESPEC * pNewSubLine = ReadLineEnumRecursive(pFile, mapCategories);
if (pNewSubLine == NULL)
{
delete pNewLineSpec;
return NULL;
}
if (pNewLineSpec->m_pEnumeratedGroup == NULL)
pNewLineSpec->m_pEnumeratedGroup = pNewSubLine;
else
{
GATH_LINESPEC * pLineSpec = pNewLineSpec->m_pEnumeratedGroup;
while (pLineSpec->m_pNext)
pLineSpec = pLineSpec->m_pNext;
pLineSpec->m_pNext = pNewSubLine;
}
}
else
{
delete pNewLineSpec;
return NULL;
}
}
if (!VerifyAndAdvanceFile(pFile, CString("}")))
{
delete pNewLineSpec;
return NULL;
}
return pNewLineSpec;
}
//-----------------------------------------------------------------------------
// This method reads in a "column" line from the file, adding the appropriate
// entries for the columns into the category referenced by dwID. The column
// line contains a bunch of fields in a list.
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::ReadColumnInfo(CFile * pFile, CMapWordToPtr & mapCategories, DWORD dwID)
{
CString strTemp;
if (!VerifyAndAdvanceFile(pFile, CString(COLUMN_KEYWORD) + CString("(")))
return FALSE;
// Get the internal category referenced by dwID.
INTERNAL_CATEGORY * pCategory = GetInternalRep(mapCategories, dwID);
if (!pCategory)
return FALSE;
// We only allow one column specifier list per node.
if (pCategory->m_pColSpec)
return FALSE;
// While we are still reading fields from the file, keep adding to the column list.
GATH_FIELD * pNewField = new GATH_FIELD;
if (pNewField == NULL)
return FALSE;
while (ReadField(pFile, *pNewField))
{
if (pCategory->m_pColSpec == NULL)
pCategory->m_pColSpec = pNewField;
else
{
// Scan to the last field in the linespec.m_pFields list, and insert the new field.
GATH_FIELD * pFieldScan = pCategory->m_pColSpec;
while (pFieldScan->m_pNext)
pFieldScan = pFieldScan->m_pNext;
pFieldScan->m_pNext = pNewField;
}
// Parse the width out of the column caption.
if (pNewField->m_strFormat.ReverseFind(_T(',')) != -1)
{
strTemp = pNewField->m_strFormat.Right(pNewField->m_strFormat.GetLength() - pNewField->m_strFormat.ReverseFind(_T(',')) - 1);
pNewField->m_usWidth = (unsigned short) _ttoi(strTemp);
pNewField->m_strFormat = pNewField->m_strFormat.Left(pNewField->m_strFormat.GetLength() - strTemp.GetLength() - 1);
}
else
{
ASSERT(FALSE);
pNewField->m_usWidth = (unsigned short) 80;
}
// Parse off any remaining information in the column label (the label ends
// with [name, n], when n is the width, and name is the ID for the column
// which should not be displayed).
if (pNewField->m_strFormat.ReverseFind(_T('[')) != -1)
pNewField->m_strFormat = pNewField->m_strFormat.Left(pNewField->m_strFormat.ReverseFind(_T('[')) - 1);
// Read the sorting type from the file.
if (ReadArgument(pFile, strTemp))
{
if (strTemp.CompareNoCase(CString(_T(SORT_LEXICAL))) == 0)
pNewField->m_sort = LEXICAL;
else if (strTemp.CompareNoCase(CString(_T(SORT_VALUE))) == 0)
pNewField->m_sort = BYVALUE;
else
pNewField->m_sort = NOSORT;
}
else
return FALSE;
// Read the complexity (BASIC or ADVANCED) from the file.
if (ReadArgument(pFile, strTemp))
{
if (strTemp.CompareNoCase(CString(_T(COMPLEXITY_ADVANCED))) == 0)
pNewField->m_datacomplexity = ADVANCED;
else
pNewField->m_datacomplexity = BASIC;
}
else
return FALSE;
pNewField = new GATH_FIELD;
if (pNewField == NULL)
return FALSE;
}
delete pNewField;
if (!VerifyAndAdvanceFile(pFile, CString(")")))
return FALSE;
return TRUE;
}
//-----------------------------------------------------------------------------
// Read in the information for a single line. Add the line to the internal
// representation of the category. NOTE: inefficient, since this will be
// called multiple times and the line list will need to be scanned to the
// end each time.
//-----------------------------------------------------------------------------
GATH_LINESPEC * CTemplateFileFunctions::ReadLineInfo(CFile * pFile)
{
if (!VerifyAndAdvanceFile(pFile, CString(LINE_KEYWORD) + CString("(")))
return NULL;
// Declare a line specification variable to store the line info.
GATH_LINESPEC * pNewLineSpec = new GATH_LINESPEC;
if (pNewLineSpec == NULL)
return NULL;
// While we are still reading fields from the file, keep adding to the column list.
// NOTE: inefficient, repeated scans through linespec.m_pFields list.
GATH_FIELD * pNewField = new GATH_FIELD;
if (pNewField == NULL)
{
delete pNewLineSpec;
return NULL;
}
// Read in the complexity (BASIC or ADVANCED) for this line.
CString strTemp;
if (ReadArgument(pFile, strTemp))
{
if (strTemp.CompareNoCase(CString(_T(COMPLEXITY_ADVANCED))) == 0)
pNewLineSpec->m_datacomplexity = ADVANCED;
else
pNewLineSpec->m_datacomplexity = BASIC;
}
else
return FALSE;
while (ReadField(pFile, *pNewField))
{
if (pNewLineSpec->m_pFields == NULL)
pNewLineSpec->m_pFields = pNewField;
else
{
// Scan to the last field in the linespec.m_pFields list, and insert the new field.
GATH_FIELD * pFieldScan = pNewLineSpec->m_pFields;
while (pFieldScan->m_pNext)
pFieldScan = pFieldScan->m_pNext;
pFieldScan->m_pNext = pNewField;
}
pNewField = new GATH_FIELD;
if (pNewField == NULL)
{
delete pNewLineSpec;
return NULL;
}
}
delete pNewField;
if (!VerifyAndAdvanceFile(pFile, CString(")")))
{
delete pNewLineSpec;
return NULL;
}
return pNewLineSpec;
}
//-----------------------------------------------------------------------------
// This method returns the next keyword in the file. Any whitespace or
// punctuation is skipped until an alphanumeric character is read. The keyword
// returned is the string starting with this character until whitespace or
// punctuation is encountered. Note: it is very important that this function
// returns the file to the state it was in when the function started, with
// the current position restored.
//
// NOTE: inefficient
//-----------------------------------------------------------------------------
BOOL CTemplateFileFunctions::GetKeyword(CFile * pFile, CString & strKeyword)
{
CString strTemp = CString("");
DWORD dwPosition = pFile->GetPosition();
WCHAR cLastChar, cCurrentChar = L'\0';
BOOL fInComment = FALSE;
// Skip over whitespace characters until we reach an alphanumeric char.
do
{
// Save the last character read, since the comment token ("//") is
// two characters long.
cLastChar = cCurrentChar;
// Read the next character in the file.
if (pFile->Read((void *) &cCurrentChar, sizeof(WCHAR)) != sizeof(WCHAR))
return FALSE;
// If we're in a comment, and the character we just read isn't a new line,
// we want to ignore it.
if (fInComment)
{
if (cCurrentChar == L'\n')
fInComment = FALSE;
continue;
}
// Check to see if we've started into a comment.
if (cCurrentChar == _T('/'))
{
if (cLastChar == _T('/'))
fInComment = TRUE;
continue;
}
} while (iswspace(cCurrentChar) || cCurrentChar == L'/' || fInComment);
// Read the keyword while it's alphanumeric.
if (iswalnum(cCurrentChar))
do
{
strTemp += (TCHAR) cCurrentChar;
if (pFile->Read((void *) &cCurrentChar, sizeof(WCHAR)) != sizeof(WCHAR))
return FALSE;
} while (iswalnum(cCurrentChar));
// Reset the file, set the keyword and return.
pFile->Seek((LONG)dwPosition, CFile::begin);
strKeyword = strTemp;
return !strTemp.IsEmpty();
}
//-----------------------------------------------------------------------------
// INTERNAL_CATEGORY constructor and destructor.
//-----------------------------------------------------------------------------
INTERNAL_CATEGORY::INTERNAL_CATEGORY()
{
m_categoryName.m_strText = CString(" ");
m_fieldName.m_strFormat = CString(" ");
m_strEnumerateClass = CString("");
m_strIdentifier = CString("");
m_strNoInstances = CString("");
m_fListView = FALSE;
m_fDynamic = FALSE;
m_dwID = 0;
m_dwParentID = 0;
m_dwChildID = 0;
m_dwPrevID = 0;
m_dwNextID = 0;
m_dwDynamicChildID = 0;
m_dwColCount = 0;
m_pColSpec = NULL;
m_aCols = NULL;
m_pLineSpec = NULL;
m_dwLineCount = 0;
m_apLines = NULL;
m_fIncluded = TRUE;
m_fRefreshed = FALSE;
m_dwLastError = S_OK; // GATH_ERR_NOERROR;
}
INTERNAL_CATEGORY::~INTERNAL_CATEGORY()
{
if (m_pColSpec)
delete m_pColSpec;
if (m_aCols)
delete [] m_aCols;
if (m_pLineSpec)
delete m_pLineSpec;
if (m_apLines)
{
for (DWORD dwIndex = 0; dwIndex < m_dwLineCount; dwIndex++)
delete m_apLines[dwIndex];
delete [] m_apLines;
}
}
//-----------------------------------------------------------------------------
// GATH_FIELD constructor and destructor.
//-----------------------------------------------------------------------------
GATH_FIELD::GATH_FIELD()
{
m_pArgs = NULL;
m_pNext = NULL;
m_usWidth = 0;
m_sort = NOSORT;
m_datacomplexity = BASIC;
}
GATH_FIELD::~GATH_FIELD()
{
if (m_pArgs) delete m_pArgs;
if (m_pNext) delete m_pNext;
}
//-----------------------------------------------------------------------------
// GATH_VALUE constructor and destructor.
//-----------------------------------------------------------------------------
GATH_VALUE::GATH_VALUE()
{
m_pNext = NULL;
m_dwValue = 0L;
}
GATH_VALUE::~GATH_VALUE()
{
if (m_pNext) delete m_pNext;
}
//-----------------------------------------------------------------------------
// GATH_LINESPEC constructor and destructor.
//-----------------------------------------------------------------------------
GATH_LINESPEC::GATH_LINESPEC()
{
m_pFields = NULL;
m_pEnumeratedGroup = NULL;
m_pConstraintFields = NULL;
m_pNext = NULL;
m_datacomplexity = BASIC;
}
GATH_LINESPEC::~GATH_LINESPEC()
{
if (m_pFields)
delete m_pFields;
if (m_pEnumeratedGroup)
delete m_pEnumeratedGroup;
if (m_pConstraintFields)
delete m_pConstraintFields;
if (m_pNext)
delete m_pNext;
}
//-----------------------------------------------------------------------------
// GATH_LINE constructor and destructor.
//-----------------------------------------------------------------------------
GATH_LINE::GATH_LINE()
{
m_datacomplexity = BASIC;
m_aValue = NULL;
}
GATH_LINE::~GATH_LINE()
{
if (m_aValue)
delete [] m_aValue;
}
//-----------------------------------------------------------------------------
// This function is called to refresh the data for all of the extensions. It
// will use the refresh index to look up the line spec, and then call some
// version 5.0 functions to do the refresh. Finally, it will convert the
// data generated by those functions into our new format.
//-----------------------------------------------------------------------------
HRESULT RefreshExtensions(CWMIHelper * pWMI, DWORD dwIndex, volatile BOOL * pfCancel, CPtrList * aColValues, int iColCount, void ** ppCache)
{
HRESULT hr = S_OK;
if (pWMI == NULL)
return hr;
pWMI->m_hrLastVersion5Error = S_OK;
// Reset the caches so the data is actually refreshed (140535).
pWMI->Version5ClearCache();
pWMI->m_enumMap.Reset();
// Get the line spec pointer for this index.
GATH_LINESPEC * pLineSpec = gmapExtensionRefreshData.Lookup(dwIndex);
if (pLineSpec == NULL)
return hr;
// Here's some code from 5.0 for refreshing a list of line pointers for a line spec.
CPtrList listLinePtrs;
if (CRefreshFunctions::RefreshLines(pWMI, pLineSpec, (DWORD) iColCount, listLinePtrs, pfCancel))
{
// Move the contents of the list of lines to our internal structures.
if (listLinePtrs.GetCount() > 0)
{
GATH_LINE * pLine;
for (POSITION pos = listLinePtrs.GetHeadPosition(); pos != NULL;)
{
pLine = (GATH_LINE *) listLinePtrs.GetNext(pos);
if (pLine == NULL || pLine->m_aValue == NULL)
continue;
for (int iCol = 0; iCol < iColCount; iCol++)
{
CString strValue = pLine->m_aValue[iCol].m_strText;
DWORD dwValue = pLine->m_aValue[iCol].m_dwValue;
BOOL fAdvanced = (pLine->m_datacomplexity == ADVANCED);
pWMI->AppendCell(aColValues[iCol], strValue, dwValue, fAdvanced);
}
delete pLine;
}
}
else
{
CString * pstrNoData = gmapExtensionRefreshData.LookupString(dwIndex);
if (pstrNoData && !pstrNoData->IsEmpty() && iColCount > 0)
{
pWMI->AppendCell(aColValues[0], *pstrNoData, 0, FALSE);
for (int iCol = 1; iCol < iColCount; iCol++)
pWMI->AppendCell(aColValues[iCol], _T(""), 0, FALSE);
}
}
}
return pWMI->m_hrLastVersion5Error;
}
//-----------------------------------------------------------------------------
// Refresh the list of lines based on the list of line fields. We'll also
// need to set the number of lines. The list of lines is generated based on
// the pLineSpec pointer and dwColumns variables. The generated lines are
// returned in the listLinePtrs parameter.
//-----------------------------------------------------------------------------
BOOL CRefreshFunctions::RefreshLines(CWMIHelper * pWMI, GATH_LINESPEC * pLineSpec, DWORD dwColumns, CPtrList & listLinePtrs, volatile BOOL * pfCancel)
{
BOOL bReturn = TRUE;
// Traverse the list of line specifiers to generate the list of lines.
GATH_LINESPEC * pCurrentLineSpec = pLineSpec;
GATH_LINE * pLine = NULL;
while (pCurrentLineSpec && (pfCancel == NULL || *pfCancel == FALSE))
{
// Check if the current line spec is for a single line or an enumerated group.
if (pCurrentLineSpec->m_strEnumerateClass.IsEmpty() || pCurrentLineSpec->m_strEnumerateClass.CompareNoCase(CString(STATIC_SOURCE)) == 0)
{
// This is for a single line. Allocate a new line structure and fill it
// in with the data generated from the line spec.
pLine = new GATH_LINE;
if (pLine == NULL)
{
bReturn = FALSE;
break;
}
if (RefreshOneLine(pWMI, pLine, pCurrentLineSpec, dwColumns))
listLinePtrs.AddTail((void *) pLine);
else
{
bReturn = FALSE;
break;
}
}
else
{
// This line represents an enumerated group of lines. We need to enumerate
// the class and call RefreshLines for the group of enumerated lines, once
// for each class instance.
if (pWMI->Version5ResetClass(pCurrentLineSpec->m_strEnumerateClass, pCurrentLineSpec->m_pConstraintFields))
do
{
if (!RefreshLines(pWMI, pCurrentLineSpec->m_pEnumeratedGroup, dwColumns, listLinePtrs, pfCancel))
break;
} while (pWMI->Version5EnumClass(pCurrentLineSpec->m_strEnumerateClass, pCurrentLineSpec->m_pConstraintFields));
}
pCurrentLineSpec = pCurrentLineSpec->m_pNext;
}
if (pfCancel && *pfCancel)
return FALSE;
// If there was a failure generating the lines, clean up after ourselves.
if (!bReturn)
{
if (pLine)
delete pLine;
for (POSITION pos = listLinePtrs.GetHeadPosition(); pos != NULL;)
{
pLine = (GATH_LINE *) listLinePtrs.GetNext(pos) ;
if (pLine)
delete pLine;
}
listLinePtrs.RemoveAll();
return FALSE;
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Refresh a line based on a line spec.
//-----------------------------------------------------------------------------
BOOL CRefreshFunctions::RefreshOneLine(CWMIHelper * pWMI, GATH_LINE * pLine, GATH_LINESPEC * pLineSpec, DWORD dwColCount)
{
// Allocate the new array of values.
if (pLine->m_aValue)
delete [] pLine->m_aValue;
pLine->m_aValue = new GATH_VALUE[dwColCount];
if (pLine->m_aValue == NULL)
return FALSE;
// Set the data complexity for the line based on the line spec.
pLine->m_datacomplexity = pLineSpec->m_datacomplexity;
// Compute each of the values for the fields.
GATH_FIELD * pField = pLineSpec->m_pFields;
for (DWORD dwIndex = 0; dwIndex < dwColCount; dwIndex++)
{
if (pField == NULL)
return FALSE;
if (!RefreshValue(pWMI, &pLine->m_aValue[dwIndex], pField))
return FALSE;
pField = pField->m_pNext;
}
return TRUE;
}
//-----------------------------------------------------------------------------
// This method takes the information in a GATH_FIELD struct and uses it to
// generate a current GATH_VALUE struct.
//-----------------------------------------------------------------------------
BOOL CRefreshFunctions::RefreshValue(CWMIHelper * pWMI, GATH_VALUE * pVal, GATH_FIELD * pField)
{
TCHAR szFormatFragment[MAX_PATH];
const TCHAR *pSourceChar;
TCHAR *pDestinationChar;
TCHAR cFormat = _T('\0');
BOOL fReadPercent = FALSE;
BOOL fReturnValue = TRUE;
CString strResult, strTemp;
int iArgNumber = 0;
DWORD dwValue = 0L;
// Process the format string. Because of the difficulty caused by having
// variable number of arguments to be inserted (like printf), we'll need
// to break the format string into chunks and do the sprintf function
// for each format flag we come across.
pSourceChar = (LPCTSTR) pField->m_strFormat;
pDestinationChar = szFormatFragment;
while (*pSourceChar)
{
if (fReadPercent)
{
// If we read a percent sign, we should be looking for a valid flag.
// We are using some additional flags to printf (and not supporting
// others). If we read another percent, just insert a single percent.
switch (*pSourceChar)
{
case _T('%'):
fReadPercent = FALSE;
break;
case _T('b'): case _T('B'):
case _T('l'): case _T('L'):
case _T('u'): case _T('U'):
case _T('s'): case _T('S'):
fReadPercent = FALSE;
cFormat = *pSourceChar;
*pDestinationChar = _T('s');
break;
case _T('t'): case _T('T'):
fReadPercent = FALSE;
cFormat = *pSourceChar;
*pDestinationChar = _T('s');
break;
case _T('x'): case _T('X'):
case _T('d'): case _T('D'):
fReadPercent = FALSE;
cFormat = _T('d');
*pDestinationChar = *pSourceChar;
break;
case _T('q'): case _T('Q'):
fReadPercent = FALSE;
cFormat = _T('q');
*pDestinationChar = _T('s');
break;
case _T('z'): case _T('Z'):
fReadPercent = FALSE;
cFormat = _T('z');
*pDestinationChar = _T('s');
break;
case _T('y'): case _T('Y'):
fReadPercent = FALSE;
cFormat = _T('y');
*pDestinationChar = _T('s');
break;
case _T('v'): case _T('V'):
fReadPercent = FALSE;
cFormat = _T('v');
*pDestinationChar = _T('s');
break;
case _T('f'): case _T('F'):
fReadPercent = FALSE;
cFormat = *pSourceChar;
*pDestinationChar = *pSourceChar;
break;
default:
*pDestinationChar = *pSourceChar;
}
}
else if (*pSourceChar == _T('%'))
{
*pDestinationChar = _T('%');
fReadPercent = TRUE;
}
else
*pDestinationChar = *pSourceChar;
pSourceChar++;
pDestinationChar++;
// If a format flag is set or we are at the end of the source string,
// then we have a complete fragment and we should produce some output,
// which will be concatenated to the strResult string.
if (cFormat || *pSourceChar == _T('\0'))
{
*pDestinationChar = _T('\0');
if (cFormat)
{
// Based on the format type, get a value from the provider for
// the next argument. Format the result using the formatting
// fragment we extracted, and concatenate it.
if (GetValue(pWMI, cFormat, szFormatFragment, strTemp, dwValue, pField, iArgNumber++))
{
strResult += strTemp;
cFormat = _T('\0');
}
else
{
strResult = strTemp;
break;
}
}
else
{
// There was no format flag, but we are at the end of the string.
// Add the fragment we got to the result string.
strResult += CString(szFormatFragment);
}
pDestinationChar = szFormatFragment;
}
}
// Assign the values we generated to the GATH_VALUE structure. Important note:
// the dwValue variable will only have ONE value, even though multiple values
// might have been generated to build the strResult string. Only the last
// value will be saved in dwValue. This is OK, because this value is only
// used for sorting a column when the column is marked for non-lexical sorting.
// In that case, there should be only one value used to generat the string.
pVal->m_strText = strResult;
pVal->m_dwValue = dwValue;
return fReturnValue;
}
//-----------------------------------------------------------------------------
// Return a string with delimiters added for the number.
//-----------------------------------------------------------------------------
CString DelimitNumber(double dblValue)
{
NUMBERFMT fmt;
TCHAR szResult[MAX_PATH] = _T("");
TCHAR szDelimiter[4] = _T(",");
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, szDelimiter, 4);
memset(&fmt, 0, sizeof(NUMBERFMT));
fmt.Grouping = 3;
fmt.lpDecimalSep = _T(""); // doesn't matter - there aren't decimal digits
fmt.lpThousandSep = szDelimiter;
CString strValue;
strValue.Format(_T("%.0f"), dblValue);
GetNumberFormat(LOCALE_USER_DEFAULT, 0, strValue, &fmt, szResult, MAX_PATH);
return CString(szResult);
}
//-----------------------------------------------------------------------------
// This method gets a single value from the provider, based on the format
// character from the template file. It formats the results using the
// format string szFormatFragment, which should only take one argument.
//-----------------------------------------------------------------------------
BOOL CRefreshFunctions::GetValue(CWMIHelper * pWMI, TCHAR cFormat, TCHAR *szFormatFragment, CString &strResult, DWORD &dwResult, GATH_FIELD *pField, int iArgNumber)
{
CString strTemp;
COleDateTime datetimeTemp;
double dblValue;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
strResult.Empty();
dwResult = 0L;
if (!pField->m_strSource.IsEmpty() && pField->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) != 0)
{
// Find the right argument for this formatting (indicated by the iArgNumber
// parameter.
GATH_VALUE * pArg = pField->m_pArgs;
while (iArgNumber && pArg)
{
pArg = pArg->m_pNext;
iArgNumber--;
}
if (pArg == NULL)
return FALSE;
switch (cFormat)
{
case 'b': case 'B':
// This is a boolean type. Show either true or false, depending on
// the numeric value.
if (pWMI->Version5QueryValueDWORD(pField->m_strSource, pArg->m_strText, dwResult, strTemp))
{
strTemp = (dwResult) ? pWMI->m_strTrue : pWMI->m_strFalse;
strResult.Format(szFormatFragment, strTemp);
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'd': case 'D':
// This is the numeric type.
if (pWMI->Version5QueryValueDWORD(pField->m_strSource, pArg->m_strText, dwResult, strTemp))
{
strResult.Format(szFormatFragment, dwResult);
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'f': case 'F':
// This is the double floating point type.
if (pWMI->Version5QueryValueDoubleFloat(pField->m_strSource, pArg->m_strText, dblValue, strTemp))
{
strResult.Format(szFormatFragment, dblValue);
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 't': case 'T':
// This is the OLE date and time type. Format the date and time into the
// string result, and return the date part in the DWORD (the day number is
// to the left of the decimal in the DATE type).
if (pWMI->Version5QueryValueDateTime(pField->m_strSource, pArg->m_strText, datetimeTemp, strTemp))
{
strResult = datetimeTemp.Format();
dwResult = (DWORD)(DATE)datetimeTemp;
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'l': case 'L':
// This is a string type, with the string converted to lower case.
if (pWMI->Version5QueryValue(pField->m_strSource, pArg->m_strText, strTemp))
{
strTemp.MakeLower();
strResult.Format(szFormatFragment, strTemp);
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'u': case 'U':
// This is a string type, with the string converted to upper case.
if (pWMI->Version5QueryValue(pField->m_strSource, pArg->m_strText, strTemp))
{
strTemp.MakeUpper();
strResult.Format(szFormatFragment, strTemp);
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 's': case 'S':
// This is the string type (string is the default type).
if (pWMI->Version5QueryValue(pField->m_strSource, pArg->m_strText, strTemp))
{
strResult.Format(szFormatFragment, strTemp);
// We only need to do this when the value returned is a number
// and is going in a column that we want to sort numerically.
// This won't break the case where a numeric string is to be
// sorted as a string because dwResult will be ignored.
if (!strTemp.IsEmpty() && iswdigit( strTemp[0]))
dwResult = _ttol( (LPCTSTR)strTemp);
return TRUE;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'q': case 'Q':
// This is a specialized type for the Win32_BIOS class. We want to show
// the "Version" property - if it isn't there, then we want to show
// the "Name" property and "ReleaseDate" properties concatenated
// together.
if (pWMI->Version5QueryValue(pField->m_strSource, CString(_T("Version")), strTemp))
{
strResult = strTemp;
return TRUE;
}
else
{
if (pWMI->Version5QueryValue(pField->m_strSource, CString(_T("Name")), strTemp))
strResult = strTemp;
if (pWMI->Version5QueryValueDateTime(pField->m_strSource, CString(_T("ReleaseDate")), datetimeTemp, strTemp))
strResult += CString(_T(" ")) + datetimeTemp.Format();
return TRUE;
}
break;
case 'z': case 'Z':
// This is a specialized size type, where the value is a numeric count
// of bytes. We want to convert it into the best possible units for
// display (for example, display "4.20 MB (4,406,292 bytes)").
if (pWMI->Version5QueryValueDoubleFloat(pField->m_strSource, pArg->m_strText, dblValue, strTemp))
{
double dValue = (double) dblValue;
DWORD dwDivisor = 1;
// Reduce the dValue to the smallest possible number (with a larger unit).
while (dValue > 1024.0 && dwDivisor < (1024 * 1024 * 1024))
{
dwDivisor *= 1024;
dValue /= 1024.0;
}
if (dwDivisor == 1)
strResult.Format(IDS_SIZEBYTES, DelimitNumber(dblValue));
else if (dwDivisor == (1024))
strResult.Format(IDS_SIZEKB_BYTES, dValue, DelimitNumber(dblValue));
else if (dwDivisor == (1024 * 1024))
strResult.Format(IDS_SIZEMB_BYTES, dValue, DelimitNumber(dblValue));
else if (dwDivisor == (1024 * 1024 * 1024))
strResult.Format(IDS_SIZEGB_BYTES, dValue, DelimitNumber(dblValue));
dwResult = (DWORD) dblValue; // So we can sort on this value (bug 391127).
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'y': case 'Y':
// This is a specialized size type, where the value is a numeric count
// of bytes, already in KB. If it's big enough, show it in MB or GB.
if (pWMI->Version5QueryValueDoubleFloat(pField->m_strSource, pArg->m_strText, dblValue, strTemp))
{
strResult.Format(IDS_SIZEKB, DelimitNumber(dblValue));
dwResult = (DWORD) dblValue; // So we can sort on this value (bug 391127).
}
else
{
strResult = strTemp;
return FALSE;
}
break;
case 'v': case 'V':
// This is a specialized type, assumed to be an LCID (locale ID). Show the
// locale.
if (pWMI->Version5QueryValue(pField->m_strSource, pArg->m_strText, strTemp))
{
// strTemp contains a string locale ID (like "0409"). Convert it into
// and actual LCID.
LCID lcid = (LCID) _tcstoul(strTemp, NULL, 16);
TCHAR szCountry[MAX_PATH];
if (GetLocaleInfo(lcid, LOCALE_SCOUNTRY, szCountry, MAX_PATH))
strResult = szCountry;
else
strResult = strTemp;
}
else
{
strResult = strTemp;
return FALSE;
}
break;
default:
ASSERT(FALSE); // unknown formatting flag
return TRUE;
}
}
return FALSE;
}
//=============================================================================
// Functions extending the CWMILiveHelper to support version 5 style refreshes.
//=============================================================================
#include "wmilive.h"
//-----------------------------------------------------------------------------
// Reset the CMSIEnumerator pointer to the start of the enumeration (and
// make sure there is one). Remove the object pointer, so the first call
// to GetObject will return the first item in the enumerator.
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5ResetClass(const CString & strClass, GATH_FIELD * pConstraints)
{
CMSIEnumerator * pMSIEnumerator = Version5GetEnumObject(strClass, pConstraints);
if (pMSIEnumerator == NULL)
return FALSE;
// Reset the enumerator, and remove the cached object pointer if there is one.
pMSIEnumerator->Reset(pConstraints);
Version5RemoveObject(strClass);
CMSIObject * pObject = Version5GetObject(strClass, pConstraints);
if (pObject == NULL || pObject->IsValid() == MOS_NO_INSTANCES)
return FALSE;
return TRUE;
}
//-----------------------------------------------------------------------------
// Move the cached IWbemClassObject pointer to the next instance.
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5EnumClass(const CString & strClass, GATH_FIELD * pConstraints)
{
// Verify that there is an object enumerator in place.
if (Version5GetEnumObject(strClass, pConstraints) == NULL)
return FALSE;
// If there is an object interface, remove it, then make a new one.
// Then retrieve the object pointer (this will do the Next on the
// enumerator to get the next instance).
Version5RemoveObject(strClass);
CMSIObject * pObject = Version5GetObject(strClass, pConstraints);
if (pObject && (pObject->IsValid() == MOS_INSTANCE))
return TRUE;
return FALSE;
}
//-----------------------------------------------------------------------------
// Retrieve the interface pointer for the specified IEnumWbemClassObject.
// If there isn't one cached, create one and cache it. It's possible for the
// pConstraints parameter to contain a field specify a WBEM SQL condition for
// this enumerator.
//-----------------------------------------------------------------------------
CMSIEnumerator * CWMILiveHelper::Version5GetEnumObject(const CString & strClass, const GATH_FIELD * pConstraints)
{
// See if we've cached this enumerator object.
CMSIEnumerator * pReturn = NULL;
if (m_mapClassToEnumInterface.Lookup(strClass, (void * &) pReturn))
return pReturn;
// We'll need to create this enumerator here, and save it in the cache.
pReturn = new CMSIEnumerator;
if (pReturn == NULL)
return NULL;
if (FAILED(pReturn->Create(strClass, pConstraints, this)))
{
delete pReturn;
return NULL;
}
m_mapClassToEnumInterface.SetAt(strClass, (void *) pReturn);
return pReturn;
}
//-----------------------------------------------------------------------------
// Remove the specified IWbemClassObject pointer from the cache.
//-----------------------------------------------------------------------------
void CWMILiveHelper::Version5RemoveObject(const CString & strClass)
{
CMSIObject * pObject = NULL;
if (m_mapClassToInterface.Lookup(strClass, (void * &) pObject) && pObject)
delete pObject;
m_mapClassToInterface.RemoveKey(strClass);
}
//-----------------------------------------------------------------------------
// Retrieve the interface pointer for the specified IWbemClassObject.
// If there isn't one cached, create one and cache it.
//-----------------------------------------------------------------------------
CMSIObject * CWMILiveHelper::Version5GetObject(const CString & strClass, const GATH_FIELD * pConstraints, CString * pstrLabel)
{
CMSIObject * pReturn = NULL;
if (m_mapClassToInterface.Lookup(strClass, (void * &) pReturn))
return pReturn;
// We don't have one of these objects cached. Get one from the enumerator.
CMSIEnumerator * pEnumerator = Version5GetEnumObject(strClass);
if (pEnumerator)
{
HRESULT hr = pEnumerator->Next(&pReturn);
if (S_OK != hr)
{
if (pReturn)
delete pReturn;
pReturn = NULL;
m_hrError = hr;
}
}
if (pReturn)
m_mapClassToInterface.SetAt(strClass, (void *) pReturn);
return pReturn;
}
//-----------------------------------------------------------------------------
// This method is used to get the current value for a given class and property
// string. Starting with the IWbemServices interface, it gets an interface
// for the requested class enums the first instance. Performance is improved
// by caching the instance interfaces in m_mapClassToInterface.
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5QueryValue(const CString & strClass, const CString & strProperty, CString & strResult)
{
strResult.Empty();
CMSIObject * pObject = Version5GetObject(strClass, NULL);
ASSERT(pObject);
if (!pObject)
return FALSE;
switch (pObject->IsValid())
{
case MOS_INSTANCE:
{
BOOL fUseValueMap = FALSE;
CString strProp(strProperty);
if (strProp.Left(8) == CString(_T("ValueMap")))
{
strProp = strProp.Right(strProp.GetLength() - 8);
fUseValueMap = TRUE;
}
VARIANT variant;
BSTR propName = strProp.AllocSysString();
VariantInit(&variant);
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
{
// If the property we just got is an array, we should convert it to string
// containing a list of the items in the array.
if ((variant.vt & VT_ARRAY) && (variant.vt & VT_BSTR) && variant.parray)
{
if (SafeArrayGetDim(variant.parray) == 1)
{
long lLower = 0, lUpper = 0;
SafeArrayGetLBound(variant.parray, 0, &lLower);
SafeArrayGetUBound(variant.parray, 0, &lUpper);
CString strWorking;
BSTR bstr = NULL;
for (long i = lLower; i <= lUpper; i++)
if (SUCCEEDED(SafeArrayGetElement(variant.parray, &i, (wchar_t*)&bstr)))
{
if (i != lLower)
strWorking += _T(", ");
strWorking += bstr;
}
strResult = strWorking;
return TRUE;
}
}
else if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
strResult = V_BSTR(&variant);
CString strFound;
if (fUseValueMap && SUCCEEDED(Version5CheckValueMap(strClass, strProp, strResult, strFound)))
strResult = strFound;
return TRUE;
}
else
strResult = m_strPropertyUnavail;
}
else
strResult = m_strBadProperty;
}
break;
case MOS_MSG_INSTANCE:
pObject->GetErrorLabel(strResult);
break;
case MOS_NO_INSTANCES:
default:
ASSERT(FALSE);
break;
}
return FALSE;
}
//-----------------------------------------------------------------------------
// This method is equivalent to QueryValue, except it returns a DWORD value.
// If FALSE is returned, then the string in strMessage should be displayed.
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5QueryValueDWORD(const CString & strClass, const CString & strProperty, DWORD & dwResult, CString & strMessage)
{
dwResult = 0L;
strMessage.Empty();
CMSIObject * pObject = Version5GetObject(strClass, NULL);
ASSERT(pObject);
if (!pObject)
return FALSE;
switch (pObject->IsValid())
{
case MOS_INSTANCE:
{
VARIANT variant;
BSTR propName = strProperty.AllocSysString();
VariantInit(&variant);
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
{
if (VariantChangeType(&variant, &variant, 0, VT_I4) == S_OK)
{
dwResult = V_I4(&variant);
return TRUE;
}
else
strMessage = m_strPropertyUnavail;
}
else
strMessage = m_strBadProperty;
}
break;
case MOS_MSG_INSTANCE:
pObject->GetErrorLabel(strMessage);
break;
case MOS_NO_INSTANCES:
default:
ASSERT(FALSE);
break;
}
return FALSE;
}
//-----------------------------------------------------------------------------
// This method is equivalent to QueryValue, except it returns a double float
// value. If FALSE is returned, then the string in strMessage should
// be displayed.
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5QueryValueDoubleFloat(const CString & strClass, const CString & strProperty, double & dblResult, CString & strMessage)
{
dblResult = 0L;
strMessage.Empty();
CMSIObject * pObject = Version5GetObject(strClass, NULL);
ASSERT(pObject);
if (!pObject)
return FALSE;
switch (pObject->IsValid())
{
case MOS_INSTANCE:
{
VARIANT variant;
BSTR propName = strProperty.AllocSysString();
VariantInit(&variant);
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
{
if (VariantChangeType(&variant, &variant, 0, VT_R8) == S_OK)
{
dblResult = V_R8(&variant);
return TRUE;
}
else
strMessage = m_strPropertyUnavail;
}
else
strMessage = m_strBadProperty;
}
break;
case MOS_MSG_INSTANCE:
pObject->GetErrorLabel(strMessage);
break;
case MOS_NO_INSTANCES:
default:
ASSERT(FALSE);
break;
}
return FALSE;
}
//-----------------------------------------------------------------------------
// This method is equivalent to QueryValue, except it returns an OLE date
// & time object. If FALSE is returned, then the string in strMessage should
// be displayed.
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5QueryValueDateTime(const CString & strClass, const CString & strProperty, COleDateTime & datetime, CString & strMessage)
{
datetime.SetDateTime(0, 1, 1, 0, 0, 0);
strMessage.Empty();
CMSIObject * pObject = Version5GetObject(strClass, NULL);
ASSERT(pObject);
if (!pObject)
return FALSE;
switch (pObject->IsValid())
{
case MOS_INSTANCE:
{
VARIANT variant;
BSTR propName = strProperty.AllocSysString();
VariantInit(&variant);
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
{
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
// Parse the date and time into an COleDateTime object. Note: we should
// be able to get an OLE date from WBEM, but for now we need to just
// deal with the string returned.
int nYear, nMonth, nDay, nHour, nMin, nSec;
CString strTemp = V_BSTR(&variant);
nYear = _ttoi(strTemp.Mid(0, 4));
nMonth = _ttoi(strTemp.Mid(4, 2));
nDay = _ttoi(strTemp.Mid(6, 2));
nHour = _ttoi(strTemp.Mid(8, 2));
nMin = _ttoi(strTemp.Mid(10, 2));
nSec = _ttoi(strTemp.Mid(12, 2));
datetime.SetDateTime(nYear, nMonth, nDay, nHour, nMin, nSec);
return TRUE;
}
else
strMessage = m_strPropertyUnavail;
}
else
strMessage = m_strBadProperty;
}
break;
case MOS_MSG_INSTANCE:
pObject->GetErrorLabel(strMessage);
break;
case MOS_NO_INSTANCES:
default:
ASSERT(FALSE);
break;
}
return FALSE;
}
//-----------------------------------------------------------------------------
// Evaluate whether or not a specific object meets the filtering requirements
// set by the constraints (filtering are the constraints where one half is
// a static value).
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5EvaluateFilter(IWbemClassObject * pObject, const GATH_FIELD * pConstraints)
{
const GATH_FIELD * pLHS = pConstraints, * pRHS = NULL;
VARIANT variant;
CString strValue;
BSTR propName;
ASSERT(pObject);
if (pObject == NULL)
return FALSE;
while (pLHS && pLHS->m_pNext)
{
pRHS = pLHS->m_pNext;
VariantInit(&variant);
// If either the left or right hand side is static, we need to do the check.
// First check out if the left side is static.
if (pLHS->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) == 0 && pRHS->m_pArgs)
{
propName = pRHS->m_pArgs->m_strText.AllocSysString();
strValue.Empty();
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
strValue = V_BSTR(&variant);
if (strValue.CompareNoCase(pLHS->m_strFormat) != 0)
return FALSE;
}
}
// Next check out if the right side is static.
if (pRHS->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) == 0 && pLHS->m_pArgs)
{
propName = pLHS->m_pArgs->m_strText.AllocSysString();
strValue.Empty();
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
strValue = V_BSTR(&variant);
if (strValue.CompareNoCase(pRHS->m_strFormat) != 0)
return FALSE;
}
}
// Advance our pointer to the left hand side by two.
pLHS = pRHS->m_pNext;
}
return TRUE;
}
//-----------------------------------------------------------------------------
// This method uses an object interface and the constraint fields to advance
// any joined classes to the correct instances.
//-----------------------------------------------------------------------------
void CWMILiveHelper::Version5EvaluateJoin(const CString & strClass, IWbemClassObject * pObject, const GATH_FIELD * pConstraints)
{
const GATH_FIELD *pLHS = pConstraints, *pRHS = NULL;
const GATH_FIELD *pEnumerated, *pJoinedTo;
GATH_FIELD fieldEnumerated, fieldJoinedTo;
VARIANT variant;
CString strValue;
BSTR propName;
ASSERT(pObject);
if (pObject == NULL)
return;
while (pLHS && pLHS->m_pNext)
{
pRHS = pLHS->m_pNext;
// If either side is static, this is a filter, rather than a join.
if ((pRHS->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) == 0) ||
(pLHS->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) == 0))
{
pLHS = pRHS->m_pNext;
continue;
}
// Find out which side refers to the class we're enumerating.
if (pRHS->m_strSource.CompareNoCase(strClass) == 0)
{
pEnumerated = pRHS;
pJoinedTo = pLHS;
}
else if (pLHS->m_strSource.CompareNoCase(strClass) == 0)
{
pEnumerated = pLHS;
pJoinedTo = pRHS;
}
else
{
pLHS = pRHS->m_pNext;
continue;
}
// Next, enumerate through the instances of the joined to class until
// we find one which satisfies the constraint. We can use the EvaluateFilter
// method to find out when the constraint is met. Set up a field pointer
// for the constraint (get the value from the enumerated class and use it
// as a static.
fieldJoinedTo = *pJoinedTo;
fieldJoinedTo.m_pNext = NULL;
VariantInit(&variant);
strValue.Empty();
if (pEnumerated->m_pArgs)
{
propName = pEnumerated->m_pArgs->m_strText.AllocSysString();
VariantClear(&variant);
if (pObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
strValue = V_BSTR(&variant);
}
}
fieldEnumerated.m_strSource = CString(STATIC_SOURCE);
fieldEnumerated.m_pNext = &fieldJoinedTo;
fieldEnumerated.m_strFormat = strValue;
// Now, enumerate the joined to class until it meets the constraints.
Version5RemoveObject(pJoinedTo->m_strSource);
Version5ResetClass(pJoinedTo->m_strSource, &fieldEnumerated);
Version5GetObject(pJoinedTo->m_strSource, &fieldEnumerated);
// Advance our pointer to the left hand side by two.
pLHS = pRHS->m_pNext;
}
// Because the GATH_FIELD destructor follows next pointers, we want
// to unlink our two GATH_FIELD locals. Also, we don't want the
// destructor for fieldJoinedTo to delete the arguments.
fieldEnumerated.m_pNext = NULL;
fieldJoinedTo.m_pArgs = NULL;
}
//-----------------------------------------------------------------------------
// Evaluate whether or not the constraints indicate that a class is being
// enumerated as a dependency class. This is currently indicated by a single
// field structure with a static value of "dependency".
//-----------------------------------------------------------------------------
BOOL CWMILiveHelper::Version5IsDependencyJoin(const GATH_FIELD * pConstraints)
{
if (pConstraints != NULL && pConstraints->m_pNext == NULL)
if (pConstraints->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) == 0)
if (pConstraints->m_strFormat.CompareNoCase(CString(DEPENDENCY_JOIN)) == 0)
return TRUE;
return FALSE;
}
//-----------------------------------------------------------------------------
// This method is used when a dependency class is being enumerated. In a
// dependency class, each property of a class instance contains a reference
// to an instance in another class. This method will cache eache of the
// instances specified by the dependency class so properties of those instances
// can be referred to in the line structures.
//-----------------------------------------------------------------------------
void CWMILiveHelper::Version5EvaluateDependencyJoin(IWbemClassObject * pObject)
{
VARIANT variant, varClassName;
IWbemClassObject * pNewObject = NULL;
//if (pObject->BeginEnumeration(WBEM_FLAG_REFS_ONLY | WBEM_FLAG_LOCAL_ONLY) == S_OK)
//while (pObject->Next(0, NULL, &variant, NULL, NULL) == S_OK)
VariantInit(&variant);
VariantClear(&variant);
if (pObject->BeginEnumeration(WBEM_FLAG_REFS_ONLY | WBEM_FLAG_NONSYSTEM_ONLY) == WBEM_S_NO_ERROR)
while (pObject->Next(0, NULL, &variant, NULL, NULL) == WBEM_S_NO_ERROR)
{
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
// Use the object path to create a pointer to the specified
// object and store it in the cache.
CString strObjectPath = V_BSTR(&variant);
BSTR bstrObjectPath = strObjectPath.AllocSysString();
HRESULT hRes = m_pIWbemServices->GetObject(bstrObjectPath, 0, NULL, &pNewObject, NULL);
if (SUCCEEDED(hRes))
{
// We need to get the class name of the new object so we know
// where to cache it. We could parse it out of the object path,
// but it will be better in the long run to get it by querying
// the new object.
if (pNewObject)
{
CString strClassName, strClassNameProp(_T("__CLASS"));
BSTR classNameProp = strClassNameProp.AllocSysString();
VariantInit(&varClassName);
VariantClear(&varClassName);
if (pNewObject->Get(classNameProp, 0L, &varClassName, NULL, NULL) == S_OK)
if (VariantChangeType(&varClassName, &varClassName, 0, VT_BSTR) == S_OK)
strClassName = V_BSTR(&varClassName);
if (!strClassName.IsEmpty())
{
CMSIObject * pNewMSIObject = new CMSIObject(pNewObject, CString(_T("")), S_OK, this, MOS_INSTANCE);
if (pNewMSIObject)
{
CMSIObject * pOldObject = NULL;
if (m_mapClassToInterface.Lookup(strClassName, (void * &) pOldObject) && pOldObject)
delete pOldObject;
m_mapClassToInterface.SetAt(strClassName, (void *) pNewMSIObject);
}
}
else
{
delete pNewObject;
pNewObject = NULL;
}
}
}
}
VariantClear(&variant);
}
}
//-----------------------------------------------------------------------------
// Remove the specified IEnumWbemClassObject pointer from the cache.
//-----------------------------------------------------------------------------
void CWMILiveHelper::Version5RemoveEnumObject(const CString & strClass)
{
CMSIEnumerator * pEnumObject = NULL;
if (m_mapClassToEnumInterface.Lookup(strClass, (void * &) pEnumObject) && pEnumObject)
delete pEnumObject;
m_mapClassToEnumInterface.RemoveKey(strClass);
}
//-----------------------------------------------------------------------------
// Clear out the contents of the caches (forcing the interfaces to be
// retrieved again).
//-----------------------------------------------------------------------------
void CWMILiveHelper::Version5ClearCache()
{
CMSIObject * pObject = NULL;
CMSIEnumerator * pEnumObject = NULL;
POSITION pos;
CString strClass;
for (pos = m_mapClassToInterface.GetStartPosition(); pos != NULL;)
{
m_mapClassToInterface.GetNextAssoc(pos, strClass, (void * &) pObject);
if (pObject)
delete pObject;
}
m_mapClassToInterface.RemoveAll();
for (pos = m_mapClassToEnumInterface.GetStartPosition(); pos != NULL;)
{
m_mapClassToEnumInterface.GetNextAssoc(pos, strClass, (void * &) pEnumObject);
if (pEnumObject)
delete pEnumObject;
}
m_mapClassToEnumInterface.RemoveAll();
}
//-----------------------------------------------------------------------------
// This function is used to retrieve a pointer to IWbemServices for a
// particular namespace. The default namespace is cimv2.
//-----------------------------------------------------------------------------
IWbemServices * CWMILiveHelper::Version5GetWBEMService(CString * pstrNamespace)
{
if (pstrNamespace == NULL || pstrNamespace->IsEmpty())
return m_pServices;
// Something like the following is useful for forcing a provider error when
// testing the error containment:
//
// if (*pstrNamespace == _T("MSAPPS")) *pstrNamespace += _T("X");
IWbemServices * pServices;
// In 5.0 we kept a map, but we probably won't do it here...
//
// if (m_mapNamespaceToService.Lookup(*pstrNamespace, (void * &) pServices) && pServices)
// return pServices;
// There is no WBEM services pointer for that namespace, we need to create one.
CString strNamespace(_T(""));
if (m_strMachine.IsEmpty())
strNamespace = CString(_T("\\\\.\\root\\")) + *pstrNamespace;
else
{
if (m_strMachine.Right(1) == CString(_T("\\")))
strNamespace = m_strMachine + CString(_T("root\\")) + *pstrNamespace;
else
strNamespace = m_strMachine + CString(_T("\\root\\")) + *pstrNamespace;
if (strNamespace.Left(2).Compare(CString(_T("\\\\"))) != 0)
strNamespace = CString(_T("\\\\")) + strNamespace;
}
IWbemLocator * pIWbemLocator = NULL;
if (CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &pIWbemLocator) == S_OK)
{
BSTR pNamespace = strNamespace.AllocSysString();
HRESULT hrServer = pIWbemLocator->ConnectServer(pNamespace, NULL, NULL, 0L, 0L, NULL, NULL, &pServices);
if (pNamespace)
SysFreeString(pNamespace);
if (pIWbemLocator)
{
pIWbemLocator->Release();
pIWbemLocator = NULL;
}
if (SUCCEEDED(hrServer) && pServices)
{
ChangeWBEMSecurity(pServices);
// In 5.0 we kept a map, but we probably won't do it here...
//
// m_mapNamespaceToService.SetAt(*pstrNamespace, (void *) pServices);
if (m_pIWbemServices)
m_pIWbemServices->Release();
m_pIWbemServices = pServices;
m_pIWbemServices->AddRef();
return pServices;
}
m_hrLastVersion5Error = hrServer;
}
return NULL;
}
//-----------------------------------------------------------------------------
// The CMSIEnumerator class encapsulates the WBEM enumerator interface, or
// implements our own form of enumerator (such as for the LNK command in the
// template file).
//
// Nothing particularly interesting about the constructor or destructor.
//-----------------------------------------------------------------------------
CMSIEnumerator::CMSIEnumerator()
{
m_enumtype = CMSIEnumerator::CLASS;
m_fOnlyDups = FALSE;
m_fGotDuplicate = FALSE;
m_fMinOfOne = FALSE;
m_iMinOfOneCount = 0;
m_pEnum = NULL;
m_pWMI = NULL;
m_pConstraints = NULL;
m_pSavedDup = NULL;
m_pstrList = NULL;
m_hresCreation = S_OK;
}
CMSIEnumerator::~CMSIEnumerator()
{
if (m_pEnum)
{
switch (m_enumtype)
{
case CMSIEnumerator::WQL:
break;
case CMSIEnumerator::LNK:
m_pWMI->m_enumMap.SetEnumerator(m_strAssocClass, m_pEnum);
break;
case CMSIEnumerator::INTERNAL:
if (m_pstrList)
{
delete m_pstrList;
m_pstrList = NULL;
}
break;
case CMSIEnumerator::CLASS:
default:
m_pWMI->m_enumMap.SetEnumerator(m_strClass, m_pEnum);
break;
}
m_pEnum->Release();
m_pEnum = NULL;
}
}
//-----------------------------------------------------------------------------
// Creating the CMSIEnumerator object involves determining what sort of
// enumerator is required. We support the following types:
//
// 1. Straight enumeration of a class
// 2. Enumerate class, with applied constraints
// 3. Enumerate the results of a WQL statement.
// 4. Interprete a LNK command to enumerate associated classes.
// 5. Do internal processing on an INTERNAL type.
//-----------------------------------------------------------------------------
HRESULT CMSIEnumerator::Create(const CString & strClass, const GATH_FIELD * pConstraints, CWMIHelper * pWMI)
{
if (strClass.IsEmpty() || !pWMI)
return E_INVALIDARG;
// Create may be called multiple times (to reset the enumerator). So we may need to
// release the enumerator pointer.
if (m_pEnum)
{
m_pEnum->Release();
m_pEnum = NULL;
}
// Divide the specified class into class and namespace parts, get the WBEM service.
CString strNamespacePart(_T("")), strClassPart(strClass);
int i = strClass.Find(_T(":"));
if (i != -1)
{
strNamespacePart = strClass.Left(i);
strClassPart = strClass.Right(strClass.GetLength() - i - 1);
}
IWbemServices * pServices = pWMI->Version5GetWBEMService(&strNamespacePart);
if (pServices == NULL)
return NULL;
// First, we need to determine what type of enumerator this is. Scan through
// the constraints - if we see one which has a string starting with "WQL:" or
// "LNK:", then we know what type this enumerator is.
CString strStatement;
const GATH_FIELD * pScanConstraint = pConstraints;
while (pScanConstraint)
{
if (pScanConstraint->m_strSource.CompareNoCase(CString(STATIC_SOURCE)) == 0)
{
if (pScanConstraint->m_strFormat.Left(4).CompareNoCase(CString(_T("WQL:"))) == 0)
m_enumtype = CMSIEnumerator::WQL;
else if (pScanConstraint->m_strFormat.Left(4).CompareNoCase(CString(_T("LNK:"))) == 0)
m_enumtype = CMSIEnumerator::LNK;
else if (pScanConstraint->m_strFormat.Left(4).CompareNoCase(CString(_T("INT:"))) == 0)
m_enumtype = CMSIEnumerator::INTERNAL;
if (m_enumtype != CMSIEnumerator::CLASS)
{
strStatement = pScanConstraint->m_strFormat;
strStatement = strStatement.Right(strStatement.GetLength() - 4);
break;
}
}
pScanConstraint = pScanConstraint->m_pNext;
}
// If this is a WQL or a LNK enumerator, processes the statement by replacing
// [class.property] with the actual value from WBEM. If we find the string
// "[min-of-one]", make a note of it for later.
if (m_enumtype == CMSIEnumerator::WQL)
ProcessEnumString(strStatement, m_fMinOfOne, m_fOnlyDups, pWMI, m_strNoInstanceLabel, TRUE);
else if (m_enumtype == CMSIEnumerator::LNK)
if (SUCCEEDED(ParseLNKCommand(strStatement, m_strObjPath, m_strAssocClass, m_strResultClass)))
{
// Save the object path for later - so we can change the object without
// completely reprocessing the statement. Then replace the keywords in
// the statement and break out the pieces again.
m_strLNKObject = m_strObjPath;
ProcessEnumString(strStatement, m_fMinOfOne, m_fOnlyDups, pWMI, m_strNoInstanceLabel);
ParseLNKCommand(strStatement, m_strObjPath, m_strAssocClass, m_strResultClass);
}
// Now, based on the enumerator type, create the WBEM enumerator object.
switch (m_enumtype)
{
case CMSIEnumerator::WQL:
{
BSTR language = SysAllocString(L"WQL");
BSTR query = strStatement.AllocSysString();
m_hresCreation = pServices->ExecQuery(language, query, WBEM_FLAG_RETURN_IMMEDIATELY, 0, &m_pEnum);
SysFreeString(query);
SysFreeString(language);
}
break;
case CMSIEnumerator::LNK:
{
m_hresCreation = ParseLNKCommand(strStatement, m_strObjPath, m_strAssocClass, m_strResultClass);
if (SUCCEEDED(m_hresCreation))
{
BSTR className = m_strAssocClass.AllocSysString();
m_pEnum = pWMI->m_enumMap.GetEnumerator(m_strAssocClass);
if (m_pEnum)
m_hresCreation = S_OK;
else
m_hresCreation = pServices->CreateInstanceEnum(className, WBEM_FLAG_SHALLOW | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &m_pEnum);
SysFreeString(className);
}
}
break;
case CMSIEnumerator::INTERNAL:
// We'll call a function here so we can do whatever processing is required
// to create this internal enumeration.
m_hresCreation = CreateInternalEnum(strStatement, pWMI);
break;
case CMSIEnumerator::CLASS:
default:
{
BSTR className = strClassPart.AllocSysString();
m_pEnum = pWMI->m_enumMap.GetEnumerator(strClassPart);
if (m_pEnum)
m_hresCreation = S_OK;
else
m_hresCreation = pServices->CreateInstanceEnum(className, WBEM_FLAG_SHALLOW | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &m_pEnum);
SysFreeString(className);
}
}
// Set some of the other member variables.
m_strClass = strClass;
m_pWMI = pWMI;
m_iMinOfOneCount = (m_fMinOfOne) ? 1 : 0;
m_pConstraints = pConstraints;
if (m_pEnum)
ChangeWBEMSecurity(m_pEnum);
// Based on the HRESULT from creating the enumeration, determine what to return.
// For certain errors, we want to act like the creation succeeded, then supply
// objects which return the error text.
if (FAILED(m_hresCreation))
{
m_fMinOfOne = TRUE;
m_iMinOfOneCount = 1;
}
pServices->Release();
return S_OK;
}
//-----------------------------------------------------------------------------
// This function is used to create internal enumeration types (enumerations
// which are beyond the template file syntax). Basically a bunch of special
// cases.
//-----------------------------------------------------------------------------
HRESULT CMSIEnumerator::CreateInternalEnum(const CString & strInternal, CWMIHelper * pWMI)
{
if (strInternal.CompareNoCase(CString(_T("dlls"))) == 0)
{
// We want to enumerate all the loaded dlls and exes on the system.
// This can be done by enumerating the CIM_ProcessExecutable class
// and removing duplicate file names. We'll keep the filenames (with
// path information) in a string list.
if (m_pstrList == NULL)
{
m_pstrList = new CStringList;
if (m_pstrList == NULL)
return E_FAIL;
}
else
m_pstrList->RemoveAll();
HRESULT hr = S_OK;
IWbemServices * pServices = pWMI->Version5GetWBEMService();
if (pServices)
{
BSTR className = SysAllocString(L"CIM_ProcessExecutable");
IEnumWbemClassObject * pEnum = NULL;
hr = pServices->CreateInstanceEnum(className, WBEM_FLAG_SHALLOW | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnum);
if (SUCCEEDED(hr))
{
IWbemClassObject * pWBEMObject = NULL;
ULONG uReturned;
VARIANT variant;
BSTR propName = SysAllocString(L"Antecedent");
VariantInit(&variant);
do
{
uReturned = 0;
hr = pEnum->Next(TIMEOUT, 1, &pWBEMObject, &uReturned);
if (SUCCEEDED(hr) && pWBEMObject && uReturned)
{
// For each instance of CIM_ProcessExecutable, get the
// Antecedent property (which contains the file path).
// If it is unique, save it in the list.
VariantClear(&variant);
if (pWBEMObject->Get(propName, 0L, &variant, NULL, NULL) == S_OK)
{
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
{
CString strResult = V_BSTR(&variant);
strResult.MakeLower();
if (m_pstrList->Find(strResult) == NULL)
m_pstrList->AddHead(strResult);
}
}
}
} while (SUCCEEDED(hr) && pWBEMObject && uReturned);
::SysFreeString(propName);
pEnum->Release();
}
::SysFreeString(className);
pServices->Release();
}
return hr;
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Help function for ProcessEnumString, used to convert single backslashes
// into double backslashes (required for WQL statements).
//-----------------------------------------------------------------------------
void MakeDoubleBackslashes(CString & strValue)
{
CString strTemp(strValue);
CString strResults;
while (!strTemp.IsEmpty())
{
if (strTemp[0] != _T('\\'))
{
int index = strTemp.Find(_T('\\'));
if (index < 0)
index = strTemp.GetLength();
strResults += strTemp.Left(index);
strTemp = strTemp.Right(strTemp.GetLength() - index);
}
else
{
strResults += CString("\\\\");
strTemp = strTemp.Mid(1);
}
}
strValue = strResults;
}
//-----------------------------------------------------------------------------
// This function replaces [class.property] with the actual value of the
// property, and strings out [min-of-one], indicating if it was present in
// the fMinOfOne parameter.
//-----------------------------------------------------------------------------
void CMSIEnumerator::ProcessEnumString(CString & strStatement, BOOL & fMinOfOne, BOOL & fOnlyDups, CWMIHelper * pWMI, CString & strNoInstanceLabel, BOOL fMakeDoubleBackslashes)
{
CString strMinOfOne(_T("min-of-one"));
CString strOnlyDups(_T("more-than-one"));
CString strResults;
fMinOfOne = FALSE;
fOnlyDups = FALSE;
while (!strStatement.IsEmpty())
{
if (strStatement[0] != _T('['))
{
int index = strStatement.Find(_T('['));
if (index < 0)
index = strStatement.GetLength();
strResults += strStatement.Left(index);
strStatement = strStatement.Right(strStatement.GetLength() - index);
}
else
{
CString strKeyword;
strStatement = strStatement.Right(strStatement.GetLength() - 1);
int index = strStatement.Find(_T(']'));
if (index < 0)
break;
strKeyword = strStatement.Left(index);
if (strKeyword.Left(strMinOfOne.GetLength()).CompareNoCase(strMinOfOne) == 0)
{
fMinOfOne = TRUE;
int iEqualsIndex = strKeyword.Find(_T('='));
if (iEqualsIndex > 0)
strNoInstanceLabel = strKeyword.Right(strKeyword.GetLength() - iEqualsIndex - 1);
}
else if (strKeyword.Left(strOnlyDups.GetLength()).CompareNoCase(strOnlyDups) == 0)
{
fOnlyDups = TRUE;
int iEqualsIndex = strKeyword.Find(_T('='));
if (iEqualsIndex > 0)
strNoInstanceLabel = strKeyword.Right(strKeyword.GetLength() - iEqualsIndex - 1);
}
else if (!strKeyword.IsEmpty())
{
int iDotIndex = strKeyword.Find(_T('.'));
if (iDotIndex >= 0)
{
CString strValue;
if (pWMI->Version5QueryValue(strKeyword.Left(iDotIndex), strKeyword.Right(strKeyword.GetLength() - iDotIndex - 1), strValue))
{
if (fMakeDoubleBackslashes)
MakeDoubleBackslashes(strValue);
strResults += strValue;
}
}
}
strStatement = strStatement.Right(strStatement.GetLength() - (index + 1));
}
}
strStatement = strResults;
}
//-----------------------------------------------------------------------------
// Parse the component classes from the LNK command.
//-----------------------------------------------------------------------------
HRESULT CMSIEnumerator::ParseLNKCommand(const CString & strStatement, CString & strObjPath, CString & strAssocClass, CString & strResultClass)
{
// We need to parse out the LNK statement into two or three components,
// from the form "objPath->assocClass[->resultClass]", with the
// brackets indicating that the resultClass is optional.
CString strWorking(strStatement);
int iArrowIndex = strWorking.Find(_T("->"));
if (iArrowIndex == -1)
return E_INVALIDARG;
strObjPath = strWorking.Left(iArrowIndex);
strWorking = strWorking.Right(strWorking.GetLength() - (iArrowIndex + 2));
iArrowIndex = strWorking.Find(_T("->"));
if (iArrowIndex == -1)
strAssocClass = strWorking;
else
{
strAssocClass = strWorking.Left(iArrowIndex);
strWorking = strWorking.Right(strWorking.GetLength() - (iArrowIndex + 2));
strResultClass = strWorking;
strResultClass.MakeLower();
}
strAssocClass.TrimRight(); strAssocClass.TrimLeft();
strObjPath.TrimRight(); strObjPath.TrimLeft();
strResultClass.TrimRight(); strResultClass.TrimLeft();
return S_OK;
}
//-----------------------------------------------------------------------------
// The Next method will advance the enumerator based on the type of this
// enumerator.
//-----------------------------------------------------------------------------
HRESULT CMSIEnumerator::Next(CMSIObject ** ppObject)
{
if (!ppObject)
return E_INVALIDARG;
*ppObject = NULL;
// If there was an error creating the enumeration, return the error code.
if (FAILED(m_hresCreation))
return m_hresCreation;
if (m_pEnum == NULL && m_enumtype != CMSIEnumerator::INTERNAL)
return E_UNEXPECTED;
HRESULT hRes = S_OK;
IWbemClassObject * pWBEMObject = NULL;
switch (m_enumtype)
{
case CMSIEnumerator::LNK:
{
// Scan through the enumerated associate class. Look for one which
// satisfies our requirements.
CString strTemp, strAssociatedObject(_T(""));
ULONG uReturned;
IWbemClassObject * pAssocObj;
do
{
pAssocObj = NULL;
uReturned = 0;
hRes = m_pEnum->Next(TIMEOUT, 1, &pAssocObj, &uReturned);
if (!pAssocObj || FAILED(hRes) || uReturned != 1)
{
// Even if we didn't succeed in getting a new object,
// we might have a saved one if we're only showing
// "more-than-one" objects.
if (m_fOnlyDups && m_pSavedDup && m_fGotDuplicate)
{
// We have found one previously, so return it.
// Make it look like the Next call was successful.
m_pSavedDup = NULL;
hRes = S_OK;
uReturned = 1;
strAssociatedObject = m_strSavedDup;
break;
}
else
{
if (m_pSavedDup)
{
// We only got one object instance, so get rid of it.
m_pSavedDup->Release();
m_pSavedDup = NULL;
}
break;
}
}
if (AssocObjectOK(pAssocObj, strTemp))
{
// This object passed the filter - but if we're showing
// only "more-than-one" objects, save this one and return
// the saved one.
if (m_fOnlyDups)
{
if (m_pSavedDup)
{
// We have found one previously, so return it and
// save the current.
IWbemClassObject * pSwap = pAssocObj;
CString strSwap = strTemp;
pAssocObj = m_pSavedDup;
m_pSavedDup = pSwap;
strTemp = m_strSavedDup;
m_strSavedDup = strSwap;
m_fGotDuplicate = TRUE;
}
else
{
// This is the first one we've found - don't
// return it until we find another.
m_pSavedDup = pAssocObj;
m_strSavedDup = strTemp;
m_fGotDuplicate = FALSE;
continue;
}
}
strAssociatedObject = strTemp;
pAssocObj->Release();
break;
}
pAssocObj->Release();
} while (pAssocObj);
// If there is an associated object path, get the object.
if (!strAssociatedObject.IsEmpty())
{
BSTR path = strAssociatedObject.AllocSysString();
if (m_pWMI->m_pIWbemServices != NULL)
hRes = m_pWMI->m_pIWbemServices->GetObject(path, 0, NULL, &pWBEMObject, NULL);
else
hRes = E_FAIL;
SysFreeString(path);
}
}
break;
case CMSIEnumerator::WQL:
{
ULONG uReturned;
hRes = m_pEnum->Next(TIMEOUT, 1, &pWBEMObject, &uReturned);
}
break;
case CMSIEnumerator::INTERNAL:
hRes = InternalNext(&pWBEMObject);
break;
case CMSIEnumerator::CLASS:
default:
{
ULONG uReturned;
// EvaluateFilter and IsDependencyJoin handle a NULL pConstraints parameter,
// but for efficiency we're going to have a distinct branch for a non-NULL
// value (since it will usually be NULL).
if (m_pConstraints)
{
// Keep enumerating the instances of this class until we've
// found one which satisfies all of the filters.
do
{
pWBEMObject = NULL;
hRes = m_pEnum->Next(TIMEOUT, 1, &pWBEMObject, &uReturned);
if (!pWBEMObject || hRes != S_OK || uReturned != 1)
break;
else if (m_pWMI->Version5EvaluateFilter(pWBEMObject, m_pConstraints))
break;
pWBEMObject->Release();
} while (pWBEMObject);
// If this class is being enumerated as a dependency class, then
// locate all the objects it references. If it isn't, we still
// need to check for any joins to other classes formed by the constraints.
if (pWBEMObject)
if (m_pWMI->Version5IsDependencyJoin(m_pConstraints))
m_pWMI->Version5EvaluateDependencyJoin(pWBEMObject);
else
m_pWMI->Version5EvaluateJoin(m_strClass, pWBEMObject, m_pConstraints);
}
else
hRes = m_pEnum->Next(TIMEOUT, 1, &pWBEMObject, &uReturned);
}
break;
}
if (pWBEMObject == NULL)
{
// There was no object to get. We'll still create a CMSIObject, but
// we'll set its state to indicate either that there are no instances,
// or one instance with an error message.
if (SUCCEEDED(hRes) && (m_iMinOfOneCount == 0))
*ppObject = new CMSIObject(pWBEMObject, m_strNoInstanceLabel, hRes, m_pWMI, MOS_NO_INSTANCES);
else
*ppObject = new CMSIObject(pWBEMObject, m_strNoInstanceLabel, hRes, m_pWMI, MOS_MSG_INSTANCE);
}
else
*ppObject = new CMSIObject(pWBEMObject, m_strNoInstanceLabel, hRes, m_pWMI, MOS_INSTANCE);
if (m_iMinOfOneCount)
m_iMinOfOneCount--;
return S_OK;
}
//-----------------------------------------------------------------------------
// InternalNext is used to return a WBEM object for an internal enumeration
// (one that requires processing beyond the template file). Basically a
// set of special cases.
//-----------------------------------------------------------------------------
HRESULT CMSIEnumerator::InternalNext(IWbemClassObject ** ppWBEMObject)
{
if (m_pstrList && !m_pstrList->IsEmpty())
{
CString strNextObject = m_pstrList->RemoveHead();
if (!strNextObject.IsEmpty())
{
IWbemServices * pServices = m_pWMI->Version5GetWBEMService();
if (pServices)
{
BSTR objectpath = strNextObject.AllocSysString();
HRESULT hr = S_OK;
if (FAILED(pServices->GetObject(objectpath, 0, NULL, ppWBEMObject, NULL)))
hr = E_FAIL;
::SysFreeString(objectpath);
pServices->Release();
return hr;
}
}
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Reset should just reset the enumerator pointer.
//-----------------------------------------------------------------------------
HRESULT CMSIEnumerator::Reset(const GATH_FIELD * pConstraints)
{
HRESULT hRes = S_OK;
if (m_pEnum)
{
switch (m_enumtype)
{
case CMSIEnumerator::WQL:
hRes = Create(m_strClass, pConstraints, m_pWMI);
break;
case CMSIEnumerator::LNK:
{
BOOL fDummy, fDummy2;
CString strDummy;
m_strObjPath = m_strLNKObject;
ProcessEnumString(m_strObjPath, fDummy, fDummy2, m_pWMI, strDummy);
m_iMinOfOneCount = (m_fMinOfOne) ? 1 : 0;
hRes = m_pEnum->Reset();
}
break;
case CMSIEnumerator::INTERNAL:
hRes = Create(m_strClass, pConstraints, m_pWMI);
break;
case CMSIEnumerator::CLASS:
default:
m_iMinOfOneCount = (m_fMinOfOne) ? 1 : 0;
hRes = m_pEnum->Reset();
break;
}
}
else
hRes = E_UNEXPECTED;
return hRes;
}
//-----------------------------------------------------------------------------
// Evaluate if the pObject parameter is valid for this LNK enumerator. In
// particular, we must find the m_strObjPath in one of its properties, and
// possibly finding another property containing the m_strResultClass string.
//-----------------------------------------------------------------------------
BOOL CMSIEnumerator::AssocObjectOK(IWbemClassObject * pObject, CString & strAssociatedObject)
{
strAssociatedObject.Empty();
ASSERT(pObject);
if (pObject == NULL)
return FALSE;
VARIANT variant;
CString strReturn(_T("")), strValue;
// Traverse the set of non-system properties. Look for one the is the same
// as the object path.
pObject->BeginEnumeration(WBEM_FLAG_REFS_ONLY | WBEM_FLAG_NONSYSTEM_ONLY);
VariantInit(&variant);
while (pObject->Next(0, NULL, &variant, NULL, NULL) == WBEM_S_NO_ERROR)
{
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
strValue = V_BSTR(&variant);
VariantClear(&variant);
if (strValue.CompareNoCase(m_strObjPath) == 0)
break;
}
pObject->EndEnumeration();
// If we found a property containing the object path, look through for other
// paths which might be to objects we're insterested in.
if (strValue.CompareNoCase(m_strObjPath) == 0)
{
pObject->BeginEnumeration(WBEM_FLAG_REFS_ONLY | WBEM_FLAG_NONSYSTEM_ONLY);
while (strReturn.IsEmpty() && (pObject->Next(0, NULL, &variant, NULL, NULL) == WBEM_S_NO_ERROR))
{
if (VariantChangeType(&variant, &variant, 0, VT_BSTR) == S_OK)
strValue = V_BSTR(&variant);
if (strValue.CompareNoCase(m_strObjPath) != 0)
{
if (m_strResultClass.IsEmpty())
strReturn = strValue;
else
{
CString strSearch(strValue);
strSearch.MakeLower();
if (strSearch.Find(m_strResultClass) != -1)
strReturn = strValue;
}
}
VariantClear(&variant);
}
pObject->EndEnumeration();
}
if (!strReturn.IsEmpty())
{
strAssociatedObject = strReturn;
return TRUE;
}
return FALSE;
}
//-----------------------------------------------------------------------------
// Implement the CMSIObject class. This is just a thin wrapper for the
// IWbemClassObject interface.
//-----------------------------------------------------------------------------
CMSIObject::CMSIObject(IWbemClassObject * pObject, const CString & strLabel, HRESULT hres, CWMIHelper * pWMI, MSIObjectState objState)
{
m_pObject = pObject;
m_strLabel = strLabel;
m_hresCreation = hres;
m_pWMI = pWMI;
m_objState = objState;
}
CMSIObject::~CMSIObject()
{
if (m_pObject)
{
m_pObject->Release();
m_pObject = NULL;
}
}
HRESULT CMSIObject::Get(BSTR property, LONG lFlags, VARIANT *pVal, VARTYPE *pvtType, LONG *plFlavor)
{
ASSERT(m_objState != MOS_NO_INSTANCES);
// If there is an object interface, just pass the request on through.
if (m_pObject)
return m_pObject->Get(property, lFlags, pVal, NULL /* pvtType */, plFlavor);
// Otherwise, we need to return the appropriate string.
CString strReturn;
GetErrorLabel(strReturn);
V_BSTR(pVal) = strReturn.AllocSysString();
pVal->vt = VT_BSTR;
return S_OK;
}
MSIObjectState CMSIObject::IsValid()
{
return m_objState;
}
HRESULT CMSIObject::GetErrorLabel(CString & strError)
{
switch (m_hresCreation)
{
case WBEM_E_ACCESS_DENIED:
strError = m_pWMI->m_strBadProperty; // shouldn't be showing errors this way in 6.0
break;
case WBEM_E_TRANSPORT_FAILURE:
strError = m_pWMI->m_strBadProperty;
break;
case S_OK:
case WBEM_S_FALSE:
default:
// This object was created from an enumeration that was marked as "min-of-one",
// meaning that at least one object, even if it's not valid, needed to be
// returned from the enumeration. Return the string we saved at object creation.
if (!m_strLabel.IsEmpty())
strError = m_strLabel;
else
strError = m_pWMI->m_strBadProperty;
break;
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Look up strVal in the ValueMap (if it exists) for strClass.strProperty
// If the value or the ValueMap is not found, return E_Something.
//
// Useful code snippet - this will dump the contents of the cache of
// saved values. To find all value mapped properties, but this code
// someplace where it will execute when MSInfo exits, change QueryValue
// to call CheckValueMap for all properties, then run MSInfo and do a global
// refresh (like to save an NFO).
//
// msiLog.WriteLog(CMSInfoLog::BASIC, _T("BEGIN Dump of ValueMap Cache\r\n"));
// CString key, val, log;
// for (POSITION pos = g_mapValueMap.GetStartPosition(); pos != NULL;)
// {
// g_mapValueMap.GetNextAssoc(pos, key, val);
// log.Format(_T(" %s = %s\r\n", key, val);
// msiLog.WriteLog(CMSInfoLog::BASIC, log);
// }
// msiLog.WriteLog(CMSInfoLog::BASIC, _T("END Dump of ValueMap Cache\r\n"));
//-----------------------------------------------------------------------------
CMapStringToString g_mapValueMap;
HRESULT CWMILiveHelper::Version5CheckValueMap(const CString& strClass, const CString& strProperty, const CString& strVal, CString &strResult)
{
IWbemClassObject * pWBEMClassObject = NULL;
HRESULT hrMap = S_OK, hr = S_OK;
VARIANT vArray, vMapArray;
IWbemQualifierSet * qual = NULL;
// Check the cache of saved values.
CString strLookup = strClass + CString(_T(".")) + strProperty + CString(_T(":")) + strVal;
if (g_mapValueMap.Lookup(strLookup, strResult))
return S_OK;
// Get the class object (not instance) for this class.
IWbemServices * pServices = Version5GetWBEMService();
if (!pServices)
return E_FAIL;
CString strFullClass(_T("\\\\.\\root\\cimv2:"));
strFullClass += strClass;
BSTR bstrObjectPath = strFullClass.AllocSysString();
hr = pServices->GetObject(bstrObjectPath, WBEM_FLAG_USE_AMENDED_QUALIFIERS, NULL, &pWBEMClassObject, NULL);
::SysFreeString(bstrObjectPath);
pServices->Release();
if (FAILED(hr))
return hr;
// Get the qualifiers from the class object.
BSTR bstrProperty = strProperty.AllocSysString();
hr = pWBEMClassObject->GetPropertyQualifierSet(bstrProperty, &qual);
::SysFreeString(bstrProperty);
if (SUCCEEDED(hr) && qual)
{
// Get the ValueMap and Value arrays.
hrMap = qual->Get(L"ValueMap", 0, &vMapArray, NULL);
hr = qual->Get(L"Values", 0, &vArray, NULL);
if (SUCCEEDED(hr) && vArray.vt == (VT_BSTR | VT_ARRAY))
{
// Get the property value we're mapping.
long index;
if (SUCCEEDED(hrMap))
{
SAFEARRAY * pma = V_ARRAY(&vMapArray);
long lLowerBound = 0, lUpperBound = 0 ;
SafeArrayGetLBound(pma, 1, &lLowerBound);
SafeArrayGetUBound(pma, 1, &lUpperBound);
BSTR vMap;
for (long x = lLowerBound; x <= lUpperBound; x++)
{
SafeArrayGetElement(pma, &x, &vMap);
if (0 == strVal.CompareNoCase((LPCTSTR)vMap))
{
index = x;
break; // found it
}
}
}
else
{
// Shouldn't hit this case - if mof is well formed
// means there is no value map where we are expecting one.
// If the strVal we are looking for is a number, treat it
// as an index for the Values array. If it's a string,
// then this is an error.
TCHAR * szTest = NULL;
index = _tcstol((LPCTSTR)strVal, &szTest, 10);
if (szTest == NULL || (index == 0 && *szTest != 0) || strVal.IsEmpty())
hr = E_FAIL;
}
// Lookup the string.
if (SUCCEEDED(hr))
{
SAFEARRAY * psa = V_ARRAY(&vArray);
long ix[1] = {index};
BSTR str2;
hr = SafeArrayGetElement(psa, ix, &str2);
if (SUCCEEDED(hr))
{
strResult = str2;
SysFreeString(str2);
hr = S_OK;
}
else
{
hr = WBEM_E_VALUE_OUT_OF_RANGE;
}
}
}
qual->Release();
}
if (SUCCEEDED(hr))
g_mapValueMap.SetAt(strLookup, strResult);
return hr;
}
//-----------------------------------------------------------------------------
// The CEnumMap is a utility class to cache IEnumWbemClassObject pointers.
// There will be one instance of this class used to improve performance
// by avoiding the high overhead associated with creating enumerators for
// certain classes.
//-----------------------------------------------------------------------------
IEnumWbemClassObject * CEnumMap::GetEnumerator(const CString & strClass)
{
IEnumWbemClassObject * pEnum = NULL;
IEnumWbemClassObject * pNewEnum = NULL;
if (m_mapEnum.Lookup(strClass, (void * &) pEnum))
{
if (pEnum && SUCCEEDED(pEnum->Clone(&pNewEnum)) && pNewEnum)
pNewEnum->Reset();
else
pNewEnum = NULL;
}
return pNewEnum;
}
void CEnumMap::SetEnumerator(const CString & strClass, IEnumWbemClassObject * pEnum)
{
if (pEnum)
{
IEnumWbemClassObject * pEnumExisting = NULL;
if (m_mapEnum.Lookup(strClass, (void * &) pEnumExisting))
{
; //WRITE(_T("SetEnumerator for %s, already exists, ignoring.\r\n"), strClass);
}
else
{
pEnum->AddRef();
m_mapEnum.SetAt(strClass, pEnum);
}
}
}
void CEnumMap::Reset()
{
IEnumWbemClassObject * pEnum = NULL;
CString key;
for (POSITION pos = m_mapEnum.GetStartPosition(); pos != NULL;)
{
m_mapEnum.GetNextAssoc(pos, key, (void * &) pEnum);
if (pEnum)
pEnum->Release();
}
m_mapEnum.RemoveAll();
}