606 lines
16 KiB
C++
606 lines
16 KiB
C++
//=============================================================================
|
|
// Contains the functions for the base WMI helper class.
|
|
//=============================================================================
|
|
|
|
#include "stdafx.h"
|
|
#include "category.h"
|
|
#include "wmiabstraction.h"
|
|
#include "resource.h"
|
|
#include "dataset.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Loads the string identified by uiResourceID, and parses it into the columns
|
|
// in aColValues. The string should be of the form "www|xxx|yyy|zzz" - this
|
|
// will be parsed into two rows: www,xxx and yyy,zzz. Values will be inserted
|
|
// into the aColValues array of pointer lists of CMSIValue structs.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CWMIHelper::LoadColumnsFromResource(UINT uiResourceID, CPtrList * aColValues, int iColCount)
|
|
{
|
|
AfxSetResourceHandle(_Module.GetResourceInstance());
|
|
|
|
CString strResource;
|
|
if (strResource.LoadString(uiResourceID))
|
|
{
|
|
CMSIValue * pValue;
|
|
int iCol = 0;
|
|
|
|
while (!strResource.IsEmpty())
|
|
{
|
|
pValue = new CMSIValue(strResource.SpanExcluding(_T("|\n")), 0);
|
|
if (pValue)
|
|
{
|
|
ASSERT(!pValue->m_strValue.IsEmpty());
|
|
strResource = strResource.Right(strResource.GetLength() - pValue->m_strValue.GetLength() - 1);
|
|
|
|
aColValues[iCol].AddTail((void *) pValue);
|
|
iCol += 1;
|
|
if (iCol == iColCount)
|
|
iCol = 0;
|
|
}
|
|
else
|
|
strResource.Empty();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Same as the previous, but uses a string instead of a resource ID.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CWMIHelper::LoadColumnsFromString(LPCTSTR szColumns, CPtrList * aColValues, int iColCount)
|
|
{
|
|
if (szColumns != NULL)
|
|
{
|
|
CString strColumns(szColumns);
|
|
CMSIValue * pValue;
|
|
int iCol = 0;
|
|
|
|
while (!strColumns.IsEmpty())
|
|
{
|
|
pValue = new CMSIValue(strColumns.SpanExcluding(_T("|\n")), 0);
|
|
if (pValue)
|
|
{
|
|
ASSERT(!pValue->m_strValue.IsEmpty());
|
|
strColumns = strColumns.Right(strColumns.GetLength() - pValue->m_strValue.GetLength() - 1);
|
|
|
|
aColValues[iCol].AddTail((void *) pValue);
|
|
iCol += 1;
|
|
if (iCol == iColCount)
|
|
iCol = 0;
|
|
}
|
|
else
|
|
strColumns.Empty();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Return the first object of the specified class.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CWMIObject * CWMIHelper::GetSingleObject(LPCTSTR szClass, LPCTSTR szProperties)
|
|
{
|
|
ASSERT(szClass);
|
|
|
|
CWMIObjectCollection * pCollection = NULL;
|
|
CWMIObject * pObject = NULL;
|
|
|
|
if (SUCCEEDED(Enumerate(szClass, &pCollection, szProperties)))
|
|
{
|
|
if (FAILED(pCollection->GetNext(&pObject)))
|
|
pObject = NULL;
|
|
delete pCollection;
|
|
}
|
|
|
|
return pObject;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Delimit the specified number.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CString DelimitNumber(double dblValue, int iDecimalDigits = 0)
|
|
{
|
|
NUMBERFMT fmt;
|
|
TCHAR szResult[MAX_PATH] = _T("");
|
|
TCHAR szDelimiter[4] = _T(",");
|
|
TCHAR szDecimal[4] = _T(".");
|
|
|
|
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, szDelimiter, 4);
|
|
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, szDecimal, 4);
|
|
|
|
memset(&fmt, 0, sizeof(NUMBERFMT));
|
|
fmt.Grouping = 3;
|
|
fmt.lpDecimalSep = (iDecimalDigits) ? szDecimal : _T("");
|
|
fmt.NumDigits = iDecimalDigits;
|
|
fmt.lpThousandSep = szDelimiter;
|
|
|
|
CString strValue;
|
|
CString strFormatString;
|
|
strFormatString.Format(_T("%%.%df"), iDecimalDigits);
|
|
strValue.Format(strFormatString, dblValue);
|
|
|
|
// GetNumberFormat requires the decimal to be a '.', while CString::Format
|
|
// uses the locale value. So we need to go back and replace it.
|
|
|
|
StringReplace(strValue, szDecimal, _T("."));
|
|
GetNumberFormat(LOCALE_USER_DEFAULT, 0, strValue, &fmt, szResult, MAX_PATH);
|
|
|
|
return CString(szResult);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Return the requested value from the object, as a string and/or a DWORD.
|
|
// Use the chFormat flag to determine how to format the results.
|
|
//
|
|
// The return result is the actual format character to use for displaying the
|
|
// results in a string.
|
|
//
|
|
// TBD - do something better with the HRESULTs returned.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CString gstrYes; // global string "yes" (will be localized)
|
|
CString gstrNo; // global string "no" (will be localized)
|
|
CString gstrBytes; // global string "bytes" (will be localized)
|
|
CString gstrKB; // global string "KB" (will be localized)
|
|
CString gstrMB; // global string "MB" (will be localized)
|
|
CString gstrGB; // global string "GB" (will be localized)
|
|
CString gstrTB; // global string "TB" (will be localized)
|
|
|
|
HRESULT CWMIObject::GetInterpretedValue(LPCTSTR szProperty, LPCTSTR szFormat, TCHAR chFormat, CString * pstrValue, DWORD * pdwValue)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
CString strValue(_T(""));
|
|
DWORD dwValue = 0;
|
|
|
|
::AfxSetResourceHandle(_Module.GetResourceInstance());
|
|
|
|
switch (chFormat)
|
|
{
|
|
case _T('s'):
|
|
case _T('u'):
|
|
case _T('l'):
|
|
{
|
|
hr = GetValueString(szProperty, &strValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (chFormat == _T('u'))
|
|
strValue.MakeUpper();
|
|
else if (chFormat == _T('l'))
|
|
strValue.MakeLower();
|
|
strValue.TrimRight();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('v'):
|
|
{
|
|
hr = GetValueValueMap(szProperty, &strValue);
|
|
}
|
|
break;
|
|
|
|
case _T('d'):
|
|
case _T('x'):
|
|
{
|
|
hr = GetValueDWORD(szProperty, &dwValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
strValue.Format(szFormat, dwValue);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('f'):
|
|
{
|
|
double dblValue;
|
|
hr = GetValueDoubleFloat(szProperty, &dblValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
strValue.Format(szFormat, dblValue);
|
|
dwValue = (DWORD) dblValue;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('b'):
|
|
{
|
|
if (gstrYes.IsEmpty())
|
|
gstrYes.LoadString(IDS_YES);
|
|
|
|
if (gstrNo.IsEmpty())
|
|
gstrNo.LoadString(IDS_NO);
|
|
|
|
hr = GetValueDWORD(szProperty, &dwValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
strValue = (dwValue) ? gstrYes : gstrNo;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('w'):
|
|
case _T('y'):
|
|
case _T('z'):
|
|
{
|
|
if (gstrBytes.IsEmpty())
|
|
gstrBytes.LoadString(IDS_BYTES);
|
|
|
|
if (gstrKB.IsEmpty())
|
|
gstrKB.LoadString(IDS_KB);
|
|
|
|
if (gstrMB.IsEmpty())
|
|
gstrMB.LoadString(IDS_MB);
|
|
|
|
if (gstrGB.IsEmpty())
|
|
gstrGB.LoadString(IDS_GB);
|
|
|
|
if (gstrTB.IsEmpty())
|
|
gstrTB.LoadString(IDS_TB);
|
|
|
|
double dblValue;
|
|
hr = GetValueDoubleFloat(szProperty, &dblValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CString strFormattedNumber;
|
|
|
|
dwValue = (DWORD) dblValue; // TBD potential loss of digits
|
|
if (chFormat == _T('w'))
|
|
strFormattedNumber = DelimitNumber(dblValue);
|
|
else
|
|
{
|
|
int iDivTimes = (chFormat == _T('y')) ? 1 : 0;
|
|
double dblWorking(dblValue);
|
|
for (; iDivTimes <= 4 && dblWorking >= 1024.0; iDivTimes++)
|
|
dblWorking /= 1024.0;
|
|
|
|
strFormattedNumber = DelimitNumber(dblWorking, (iDivTimes) ? 2 : 0);
|
|
switch (iDivTimes)
|
|
{
|
|
case 0:
|
|
strFormattedNumber += _T(" ") + gstrBytes;
|
|
break;
|
|
|
|
case 1:
|
|
strFormattedNumber += _T(" ") + gstrKB;
|
|
break;
|
|
|
|
case 2:
|
|
strFormattedNumber += _T(" ") + gstrMB;
|
|
break;
|
|
|
|
case 3:
|
|
strFormattedNumber += _T(" ") + gstrGB;
|
|
break;
|
|
|
|
case 4:
|
|
strFormattedNumber += _T(" ") + gstrTB;
|
|
break;
|
|
}
|
|
|
|
if (chFormat == _T('z') && iDivTimes)
|
|
strFormattedNumber += _T(" (") + DelimitNumber(dblValue) + _T(" ") + gstrBytes + _T(")");
|
|
}
|
|
|
|
strValue = strFormattedNumber;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('t'):
|
|
{
|
|
COleDateTime oledatetime;
|
|
SYSTEMTIME systimeValue;
|
|
|
|
hr = GetValueTime(szProperty, &systimeValue);
|
|
oledatetime = (COleDateTime) systimeValue;
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
dwValue = (DWORD)(DATE)oledatetime;
|
|
|
|
// Try to get the date in the localized format.
|
|
|
|
strValue.Empty();
|
|
TCHAR szBuffer[MAX_PATH]; // seems plenty big
|
|
if (::GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systimeValue, NULL, szBuffer, MAX_PATH))
|
|
{
|
|
strValue = szBuffer;
|
|
if (::GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &systimeValue, NULL, szBuffer, MAX_PATH))
|
|
strValue += CString(_T(" ")) + CString(szBuffer);
|
|
}
|
|
|
|
// Fall back on our old (partially incorrect) method.
|
|
|
|
if (strValue.IsEmpty())
|
|
strValue = oledatetime.Format(0, LOCALE_USER_DEFAULT);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('c'):
|
|
{
|
|
COleDateTime oledatetime;
|
|
SYSTEMTIME systimeValue;
|
|
|
|
hr = GetValueTime(szProperty, &systimeValue);
|
|
oledatetime = (COleDateTime) systimeValue;
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
dwValue = (DWORD)(DATE)oledatetime;
|
|
|
|
// Try to get the date in the localized format.
|
|
|
|
strValue.Empty();
|
|
TCHAR szBuffer[MAX_PATH]; // seems plenty big
|
|
if (::GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systimeValue, NULL, szBuffer, MAX_PATH))
|
|
strValue = szBuffer;
|
|
|
|
// Fall back on our old (partially incorrect) method.
|
|
|
|
if (strValue.IsEmpty())
|
|
strValue = oledatetime.Format(0, LOCALE_USER_DEFAULT);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _T('a'):
|
|
{
|
|
hr = GetValueString(szProperty, &strValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// strValue contains a string locale ID (like "0409"). Convert it into
|
|
// and actual LCID.
|
|
|
|
LCID lcid = (LCID) _tcstoul(strValue, NULL, 16);
|
|
TCHAR szCountry[MAX_PATH];
|
|
if (GetLocaleInfo(lcid, LOCALE_SCOUNTRY, szCountry, MAX_PATH))
|
|
strValue = szCountry;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
// Just continue with the loop.
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pstrValue)
|
|
{
|
|
if (chFormat == _T('d') || chFormat == _T('x') || chFormat == _T('f'))
|
|
*pstrValue = strValue;
|
|
else
|
|
{
|
|
CString strFormat(szFormat);
|
|
|
|
int iPercent = strFormat.Find(_T("%"));
|
|
int iLength = strFormat.GetLength();
|
|
if (iPercent != -1)
|
|
{
|
|
while (iPercent < iLength && strFormat[iPercent] != chFormat)
|
|
iPercent++;
|
|
|
|
if (iPercent < iLength)
|
|
{
|
|
strFormat.SetAt(iPercent, _T('s'));
|
|
pstrValue->Format(strFormat, strValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pdwValue)
|
|
*pdwValue = dwValue;
|
|
}
|
|
else
|
|
{
|
|
if (pstrValue)
|
|
*pstrValue = GetMSInfoHRESULTString(hr);
|
|
if (pdwValue)
|
|
*pdwValue = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// These functions implement features found in the new versions of MFC (new
|
|
// than what we're currently building with).
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int StringFind(CString & str, LPCTSTR szLookFor, int iStartFrom)
|
|
{
|
|
CString strWorking(str.Right(str.GetLength() - iStartFrom));
|
|
int iFind = strWorking.Find(szLookFor);
|
|
|
|
if (iFind != -1)
|
|
iFind += iStartFrom;
|
|
|
|
return iFind;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Process the specified string. It will contain a format string with one
|
|
// or more flags (flags specific to MSInfo). We need to replace is flag with
|
|
// a properly formatted value from pObject, determined by the next property
|
|
// in pstrProperties.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL ProcessColumnString(CMSIValue * pValue, CWMIObject * pObject, CString * pstrProperties)
|
|
{
|
|
CString strPropertyValue, strProperty, strFragment;
|
|
CString strResults(_T(""));
|
|
CString strFormatString(pValue->m_strValue);
|
|
DWORD dwResults;
|
|
BOOL fAdvanced = FALSE;
|
|
BOOL fAllPiecesFailed = TRUE;
|
|
HRESULT hr = S_OK;
|
|
|
|
while (!strFormatString.IsEmpty() && SUCCEEDED(hr))
|
|
{
|
|
// Get the next fragment of the format string with a single format specifier.
|
|
|
|
int iPercent = strFormatString.Find(_T("%"));
|
|
if (iPercent == -1)
|
|
{
|
|
strResults += strFormatString;
|
|
break;
|
|
}
|
|
|
|
int iSecondPercent = StringFind(strFormatString, _T("%"), iPercent + 1);
|
|
if (iSecondPercent == -1)
|
|
{
|
|
strFragment = strFormatString;
|
|
strFormatString.Empty();
|
|
}
|
|
else
|
|
{
|
|
strFragment = strFormatString.Left(iSecondPercent);
|
|
strFormatString = strFormatString.Right(strFormatString.GetLength() - iSecondPercent);
|
|
}
|
|
|
|
// Find the format character for this fragment.
|
|
|
|
TCHAR chFormat;
|
|
do
|
|
chFormat = strFragment[++iPercent];
|
|
while (!_istalpha(chFormat));
|
|
|
|
// Get the property name for this fragment.
|
|
|
|
int iComma = pstrProperties->Find(_T(","));
|
|
if (iComma != -1)
|
|
{
|
|
strProperty = pstrProperties->Left(iComma);
|
|
*pstrProperties = pstrProperties->Right(pstrProperties->GetLength() - iComma - 1);
|
|
}
|
|
else
|
|
{
|
|
strProperty = *pstrProperties;
|
|
pstrProperties->Empty();
|
|
}
|
|
strProperty.TrimLeft();
|
|
strProperty.TrimRight();
|
|
|
|
if (strProperty.Left(11) == CString(_T("MSIAdvanced")))
|
|
{
|
|
fAdvanced = TRUE;
|
|
strProperty = strProperty.Right(strProperty.GetLength() - 11);
|
|
}
|
|
|
|
// Get the actual value the property and add it to the string.
|
|
|
|
hr = pObject->GetInterpretedValue(strProperty, strFragment, chFormat, &strPropertyValue, &dwResults);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fAllPiecesFailed = FALSE;
|
|
strResults += strPropertyValue;
|
|
}
|
|
else
|
|
strResults += GetMSInfoHRESULTString(hr);
|
|
}
|
|
|
|
if (!fAllPiecesFailed)
|
|
{
|
|
pValue->m_strValue = strResults;
|
|
pValue->m_dwValue = dwResults;
|
|
}
|
|
else
|
|
{
|
|
pValue->m_strValue = GetMSInfoHRESULTString(hr);
|
|
pValue->m_dwValue = 0;
|
|
}
|
|
pValue->m_fAdvanced = fAdvanced;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A general purpose function to add the contents of object pObject to the
|
|
// columns, based on the properties in szProperties and the string referenced
|
|
// by uiColumns.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CWMIHelper::AddObjectToOutput(CPtrList * aColValues, int iColCount, CWMIObject * pObject, LPCTSTR szProperties, UINT uiColumns)
|
|
{
|
|
POSITION aPositions[32]; // should never be more than 32 columns
|
|
ASSERT(iColCount < 32);
|
|
|
|
CString strProperties(szProperties);
|
|
|
|
// Save the starting position for the new entries we're adding from the resoure.
|
|
|
|
int iColListStart = (int)aColValues[0].GetCount();
|
|
LoadColumnsFromResource(uiColumns, aColValues, iColCount);
|
|
|
|
// Look through each of the new cells. For each string in a cell, if we
|
|
// find a formatting flag (like %s), get the next property out of the
|
|
// property list and format the string.
|
|
|
|
for (int iCol = 0; iCol < iColCount; iCol++)
|
|
aPositions[iCol] = aColValues[iCol].FindIndex(iColListStart);
|
|
|
|
while (aPositions[0])
|
|
for (iCol = 0; iCol < iColCount; iCol++)
|
|
{
|
|
ASSERT(aPositions[iCol]);
|
|
if (aPositions[iCol])
|
|
{
|
|
CMSIValue * pValue = (CMSIValue *) aColValues[iCol].GetNext(aPositions[iCol]);
|
|
if (pValue && pValue->m_strValue.Find(_T("%")) != -1)
|
|
ProcessColumnString(pValue, pObject, &strProperties);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Same as previous, but takes a string instead of a resource ID.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CWMIHelper::AddObjectToOutput(CPtrList * aColValues, int iColCount, CWMIObject * pObject, LPCTSTR szProperties, LPCTSTR szColumns)
|
|
{
|
|
POSITION aPositions[32]; // should never be more than 32 columns
|
|
ASSERT(iColCount < 32);
|
|
|
|
CString strProperties(szProperties);
|
|
|
|
// Save the starting position for the new entries we're adding from the resoure.
|
|
|
|
int iColListStart = (int)aColValues[0].GetCount();
|
|
LoadColumnsFromString(szColumns, aColValues, iColCount);
|
|
|
|
// Look through each of the new cells. For each string in a cell, if we
|
|
// find a formatting flag (like %s), get the next property out of the
|
|
// property list and format the string.
|
|
|
|
for (int iCol = 0; iCol < iColCount; iCol++)
|
|
aPositions[iCol] = aColValues[iCol].FindIndex(iColListStart);
|
|
|
|
while (aPositions[0])
|
|
for (iCol = 0; iCol < iColCount; iCol++)
|
|
{
|
|
ASSERT(aPositions[iCol]);
|
|
if (aPositions[iCol])
|
|
{
|
|
CMSIValue * pValue = (CMSIValue *) aColValues[iCol].GetNext(aPositions[iCol]);
|
|
if (pValue && pValue->m_strValue.Find(_T("%")) != -1)
|
|
ProcessColumnString(pValue, pObject, &strProperties);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWMIHelper::AppendBlankLine(CPtrList * aColValues, int iColCount, BOOL fOnlyIfNotEmpty)
|
|
{
|
|
if (aColValues[0].GetCount() || fOnlyIfNotEmpty == FALSE)
|
|
for (int iCol = 0; iCol < iColCount; iCol++)
|
|
AppendCell(aColValues[iCol], _T(""), 0);
|
|
}
|
|
|
|
void CWMIHelper::AppendCell(CPtrList & listColumns, const CString & strValue, DWORD dwValue, BOOL fAdvanced)
|
|
{
|
|
CMSIValue * pValue = new CMSIValue(strValue, dwValue, fAdvanced);
|
|
if (pValue)
|
|
listColumns.AddTail((void *) pValue);
|
|
}
|