/*++
Copyright (C) 1997-2001 Microsoft Corporation
Module Name:
Abstract:
History:
--*/
// OpWrap.cpp
#include "stdafx.h"
#include "OpWrap.h"
#include "resource.h"
#include "OpView.h"
#include "MainFrm.h"
void Trace(LPCTSTR szFormat, ...)
{
va_list ap;
TCHAR szMessage[512];
va_start(ap, szFormat);
_vstprintf(szMessage, szFormat, ap);
va_end(ap);
lstrcat(szMessage, _T("\n"));
OutputDebugString(szMessage);
}
CString GetEmbeddedObjectText(IUnknown *pUnk)
{
IWbemClassObjectPtr pObj;
CString strRet;
if (pUnk)
{
pUnk->QueryInterface(
IID_IWbemClassObject,
(LPVOID*) &pObj);
if (pObj != NULL)
{
CObjInfo obj;
obj.SetObj(pObj);
strRet = obj.GetObjText();
}
}
else
strRet.LoadString(IDS_NULL);
return strRet;
}
/////////////////////////////////////////////////////////////////////////////
// CObjInfo
CObjInfo::~CObjInfo()
{
}
BOOL CObjInfo::GetPropValue(int iIndex, CString &strValue, BOOL bTranslate)
{
BOOL bRet;
_variant_t var;
CPropInfo &prop = (*m_ppProps)[iIndex];
ValueToVariant(iIndex, &var);
bRet = prop.VariantToString(&var, strValue, bTranslate);
// Otherwise the destructor freaks out because it doesn't know what to do
// with VT_I8.
if (var.vt == VT_I8)
var.vt = VT_I4;
return bRet;
}
CString CObjInfo::GetStringPropValue(int iIndex)
{
_bstr_t strProp = m_ppProps->GetData()[iIndex].m_strName;
return GetStringPropValue(strProp);
}
CString CObjInfo::GetStringPropValue(LPCWSTR szName)
{
CString strRet;
_variant_t var;
if (m_pObj != NULL)
{
m_pObj->Get(
szName,
0,
&var,
NULL,
NULL);
}
if (var.vt == VT_BSTR)
strRet = var.bstrVal;
return strRet;
}
#define KEY_PROP_FORMAT _T("\t\t%s (%s)* = %s\n")
#define NON_KEY_PROP_FORMAT _T("\t\t%s (%s) = %s\n")
void CObjInfo::Export(CStdioFile *pFile, BOOL bShowSystem, BOOL bTranslate,
int iLevel)
{
#ifdef _DEBUG
// Don't leave this in here! It's a hack I'm using to check out the
// internal layout of IWbemClassObject.
DoDebugStuff();
#endif
CPropInfo *pProps;
int nItems;
// Get out if the object isn't valid (like on an object where the
// refresh failed).
if (m_pObj == NULL)
return;
pProps = GetProps()->GetData();
nItems = GetProps()->GetSize();
// Add the object path.
for (int i = 0; i <= iLevel; i++)
pFile->Write(_T("\t"), sizeof(TCHAR));
pFile->WriteString(GetObjText());
pFile->Write(_T("\n"), sizeof(TCHAR));
for (i = 0; i < nItems; i++)
{
if (bShowSystem || pProps[i].m_iFlavor != WBEM_FLAVOR_ORIGIN_SYSTEM)
{
CString strLine,
strType,
strValue;
_variant_t vValue;
IUnknown **pUnks = NULL;
int nUnks = 0,
iImage;
BOOL bArray;
pProps[i].GetPropType(strType, &iImage);
ValueToVariant(i, &vValue);
if (vValue.vt == VT_UNKNOWN)
{
bArray = FALSE;
nUnks = 1;
pUnks = &vValue.punkVal;
}
else if (vValue.vt == ((int) VT_UNKNOWN | VT_ARRAY))
{
bArray = TRUE;
nUnks = vValue.parray->rgsabound[0].cElements;
pUnks = (IUnknown**) vValue.parray->pvData;
}
else
pProps[i].VariantToString(&vValue, strValue, bTranslate, TRUE);
strLine.Format(
pProps[i].m_bKey ? KEY_PROP_FORMAT : NON_KEY_PROP_FORMAT,
(LPCTSTR) pProps[i].m_strName,
(LPCTSTR) strType,
(LPCTSTR) strValue);
// Add some additional space if we're in a nested level.
for (int i = 0; i < iLevel; i++)
pFile->Write(_T("\t"), sizeof(TCHAR));
pFile->WriteString(strLine);
// Now do the embedded object stuff.
if (nUnks)
{
for (int i = 0; i < nUnks; i++)
{
IWbemClassObjectPtr pObj;
HRESULT hr;
hr =
pUnks[i]->QueryInterface(
IID_IWbemClassObject,
(LPVOID*) &pObj);
if (SUCCEEDED(hr))
{
CObjInfo info;
info.SetObj(pObj);
info.SetBaseImage(IMAGE_OBJECT);
info.LoadProps(NULL);
info.Export(pFile, bShowSystem, bTranslate, iLevel + 2);
// This looks bad, but normally this is done by a
// controlling COpWrap. In this case we faked one, so
// we have to get rid of it ourselves.
delete info.GetProps();
}
}
}
// Otherwise the destructor freaks out because it doesn't know what to do
// with VT_I8.
if (vValue.vt == VT_I8)
vValue.vt = VT_I4;
}
}
// Leave room for another one.
pFile->Write(_T("\n"), sizeof(TCHAR));
}
CString CObjInfo::GetObjText()
{
CString strRet = GetStringPropValue(L"__RELPATH");
if (strRet.IsEmpty())
{
CString strClass = GetStringPropValue(L"__CLASS");
if (!strClass.IsEmpty())
strRet.Format(IDS_CLASS_NO_KEY, (LPCTSTR) strClass);
else
strRet.LoadString(IDS_NO_KEY);
}
return strRet;
}
#define MAX_STR_SIZE 4096
BOOL CObjInfo::ValueToVariant(int iIndex, VARIANT *pVar)
{
CPropInfo &prop = (*m_ppProps)[iIndex];
BOOL bRet = FALSE;
VariantClear(pVar);
pVar->vt = VT_NULL;
if (prop.m_iHandle && !(prop.m_type & CIM_FLAG_ARRAY))
{
BOOL bString = prop.m_vt == VT_BSTR;
long nRead = 0;
if (bString)
{
WCHAR szBuff[MAX_STR_SIZE];
bRet =
SUCCEEDED(m_pAccess->ReadPropertyValue(
prop.m_iHandle,
prop.m_dwExpectedSize,
&nRead,
(LPBYTE) szBuff)) && nRead != 0;
if (bRet)
{
pVar->vt = VT_BSTR;
V_BSTR(pVar) = SysAllocString(szBuff);
}
}
else
{
bRet =
SUCCEEDED(m_pAccess->ReadPropertyValue(
prop.m_iHandle,
prop.m_dwExpectedSize,
&nRead,
(LPBYTE) &V_BSTR(pVar))) &&
(nRead == prop.m_dwExpectedSize);
if (bRet)
pVar->vt = prop.m_vt;
}
}
else
{
bRet = SUCCEEDED(m_pObj->Get(
_bstr_t(prop.m_strName),
0,
pVar,
NULL,
NULL));
}
return bRet;
}
CString GetStringPropType(int iIndex);
void CObjInfo::GetPropInfo(
int iIndex,
CString &strValue,
CString &strType,
int *piImage,
int *piFlavor,
BOOL bTranslate)
{
CPropInfo &info = (*m_ppProps)[iIndex];
info.GetPropType(strType, piImage);
strValue = _T("");
*piFlavor = info.m_iFlavor;
GetPropValue(iIndex, strValue, bTranslate);
}
void CObjInfo::SetObj(IWbemClassObject *pObj)
{
m_pObj = pObj;
pObj->QueryInterface(
IID_IWbemObjectAccess,
(LPVOID*) &m_pAccess);
}
BOOL IsVarStringArray(VARIANT *pVar)
{
return pVar->vt == (VT_BSTR | VT_ARRAY) &&
pVar->parray->rgsabound[0].cElements != 0;
}
// This converts a BitMap qualifier value string into a bitmask scalar value.
// If the number is a decimal number we have to shift it (e.g. convert '3',
// or bit 3 (zero based), into 0x8.
// If the number is hex, just use wcstoul to convert it into a DWORD.
DWORD CObjInfo::BitmaskStrToValue(LPCWSTR szStr)
{
WCHAR *szBad;
if (szStr[0] && towupper(szStr[1]) != 'X')
return 1 << wcstoul(szStr, &szBad, 0);
else
return wcstoul(szStr, &szBad, 0);
}
HRESULT CObjInfo::LoadProps(IWbemServices *pNamespace)
{
// We need to get the class definition for the amended qualifiers.
IWbemClassObjectPtr pClass;
CString strClass = GetStringPropValue(L"__CLASS");
if (!m_ppProps)
m_ppProps = new CPropInfoArray;
if (pNamespace)
{
pNamespace->GetObject(
_bstr_t(strClass),
WBEM_FLAG_USE_AMENDED_QUALIFIERS,
NULL,
&pClass,
NULL);
}
SAFEARRAY *pArr = NULL;
HRESULT hr;
CMap<CString, LPCTSTR, BOOL, BOOL>
mapNameToKey;
_variant_t vTrue(true);
// Find our key properties
if (SUCCEEDED(m_pObj->GetNames(
L"KEY",
WBEM_FLAG_ONLY_IF_IDENTICAL,
&vTrue,
&pArr)) && pArr->rgsabound[0].cElements != 0)
{
BSTR *pNames = (BSTR*) pArr->pvData;
for (int i = 0;
i < pArr->rgsabound[0].cElements;
i++)
{
mapNameToKey.SetAt(_bstr_t(pNames[i]), TRUE);
}
SafeArrayDestroy(pArr);
}
// Find out how big we need to make our array.
if (SUCCEEDED(hr = m_pObj->GetNames(
NULL,
WBEM_FLAG_ALWAYS,
NULL,
&pArr)) && pArr->rgsabound[0].cElements != 0)
{
BSTR *pNames = (BSTR*) pArr->pvData;
m_ppProps->SetSize(pArr->rgsabound[0].cElements);
for (int i = 0;
i < pArr->rgsabound[0].cElements && SUCCEEDED(hr);
i++)
{
BOOL bKey; // This value isn't really used, but we need it for the
// mapNameToKey.Lookup call.
CPropInfo &info = (*m_ppProps)[i];
CIMTYPE type;
m_pObj->Get(pNames[i], 0, NULL, &type, &info.m_iFlavor);
info.m_strName = (LPCWSTR) _bstr_t(pNames[i]);
BOOL bSystemProp = info.m_iFlavor == WBEM_FLAVOR_ORIGIN_SYSTEM;
// Don't bother getting the handle for system props since they don't
// exist.
if (!bSystemProp)
m_pAccess->GetPropertyHandle(pNames[i], NULL, &info.m_iHandle);
info.SetType(type);
if (mapNameToKey.Lookup(info.m_strName, bKey))
info.m_bKey = TRUE;
// Load up the valuemap/bitmap values.
IWbemQualifierSetPtr pQuals;
if (pClass != NULL &&
SUCCEEDED(pClass->GetPropertyQualifierSet(pNames[i], &pQuals)))
{
_variant_t vValues;
// Try to get the Values/Valuemap stuff.
if (SUCCEEDED(pQuals->Get(L"Values", 0, &vValues, NULL)) &&
IsVarStringArray(&vValues))
{
_variant_t vMap;
BOOL bUsingMap;
bUsingMap = SUCCEEDED(pQuals->Get(L"ValueMap", 0, &vMap, NULL)) &&
IsVarStringArray(&vMap) &&
vMap.parray->rgsabound[0].cElements ==
vValues.parray->rgsabound[0].cElements;
// Indicate whether this property will be using
// m_mapValues.
info.m_bValueMap =
vValues.parray->rgsabound[0].cElements != 0;
// Clear this out in case we're refreshing our data.
info.m_mapValues.RemoveAll();
for (int i = 0; i < vValues.parray->rgsabound[0].cElements;
i++)
{
CString strKey,
strValue;
if (bUsingMap)
strKey = ((BSTR*)(vMap.parray->pvData))[i];
else
strKey.Format(_T("%d"), i);
strValue = ((BSTR*)(vValues.parray->pvData))[i];
info.m_mapValues.SetAt(strKey, strValue);
}
}
// Try to get the Values/Valuemap stuff.
if (SUCCEEDED(pQuals->Get(L"BitValues", 0, &vValues, NULL)) &&
IsVarStringArray(&vValues))
{
_variant_t vMap;
BOOL bUsingBitmap;
bUsingBitmap = SUCCEEDED(pQuals->Get(L"BitMap", 0, &vMap, NULL)) &&
IsVarStringArray(&vMap) &&
vMap.parray->rgsabound[0].cElements ==
vValues.parray->rgsabound[0].cElements;
// Indicate whether this property will be using
// m_bitmaskValues.
info.m_bBitmask =
vValues.parray->rgsabound[0].cElements != 0;
if (info.m_bBitmask)
info.m_bitmaskValues.SetSize(
vValues.parray->rgsabound[0].cElements);
for (int i = 0; i < vValues.parray->rgsabound[0].cElements;
i++)
{
CString strValue;
CBitmaskInfo &value = info.m_bitmaskValues[i];
if (bUsingBitmap)
value.m_dwBitmaskValue =
BitmaskStrToValue(((BSTR*)(vMap.parray->pvData))[i]);
else
value.m_dwBitmaskValue = 1 << i;
value.m_strName = ((BSTR*)(vValues.parray->pvData))[i];
}
}
}
}
SafeArrayDestroy(pArr);
}
// Load up the methods.
m_ppProps->LoadMethods(pClass);
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// COpWrap
COpWrap::COpWrap() :
m_nCount(0),
m_status(WBEM_STATUS_COMPLETE),
m_nExpectedStatusCalls(0),
m_lRef(0)
{
}
COpWrap::COpWrap(
WMI_OP_TYPE type,
LPCTSTR szText,
BOOL bOption) :
m_nCount(0),
m_strOpText(szText),
m_type(type),
m_status(WBEM_STATUS_COMPLETE),
m_bOption(bOption),
m_nExpectedStatusCalls(0),
m_lRef(0)
{
Init();
}
COpWrap::~COpWrap()
{
}
STDMETHODIMP_(ULONG) CObjSink::AddRef(void)
{
LONG lRet = InterlockedIncrement(&m_lRef);
//Trace("Addref = %d", m_lRef);
return lRet;
}
STDMETHODIMP_(ULONG) CObjSink::Release(void)
{
LONG lRet = InterlockedDecrement(&m_lRef);
//Trace("Release = %d", m_lRef);
if (lRet == 0)
delete this;
return lRet;
}
HRESULT STDMETHODCALLTYPE CObjSink::Indicate(
LONG lObjectCount,
IWbemClassObject **ppObjArray)
{
return m_pWrap->Indicate(lObjectCount, ppObjArray);
}
HRESULT STDMETHODCALLTYPE CObjSink::SetStatus(
LONG lFlags,
HRESULT hResult,
BSTR strParam,
IWbemClassObject *pObjParam)
{
return m_pWrap->SetStatus(lFlags, hResult, strParam, pObjParam);
}
const COpWrap& COpWrap::operator=(const COpWrap &other)
{
m_strOpText = other.m_strOpText;
m_type = other.m_type;
m_bOption = other.m_bOption;
return *this;
}
HRESULT COpWrap::Execute(IWbemServices *pNamespace)
{
_bstr_t strWQL = L"WQL",
strText = m_strOpText;
m_hr = S_OK;
m_pNamespace = pNamespace;
m_nCount = 0;
m_status = WBEM_STATUS_PROGRESS;
m_strProps.RemoveAll();
m_piDisplayCols.RemoveAll();
m_mapClassToProps.Flush();
m_hr = S_OK;
m_nExpectedStatusCalls++;
CObjSink *pSink = new CObjSink(this);
m_pObjSink = pSink;
// It seems like WMI never does this. Why?
//pSink->AddRef();
switch(m_type)
{
case WMI_QUERY:
m_hr =
pNamespace->ExecQueryAsync(
strWQL,
strText,
WBEM_FLAG_USE_AMENDED_QUALIFIERS,
NULL,
m_pObjSink);
//(IWbemObjectSink*) this);
break;
case WMI_EVENT_QUERY:
m_hr =
pNamespace->ExecNotificationQueryAsync(
strWQL,
strText,
WBEM_FLAG_USE_AMENDED_QUALIFIERS |
(m_bOption ? WBEM_FLAG_MONITOR : 0),
NULL,
m_pObjSink);
//(IWbemObjectSink*) this);
break;
case WMI_ENUM_OBJ:
m_hr =
pNamespace->CreateInstanceEnumAsync(
strText,
//WBEM_FLAG_FORWARD_ONLY | // WMI doesn't seem to like this. Why?
WBEM_FLAG_USE_AMENDED_QUALIFIERS |
(m_bOption ? WBEM_FLAG_DEEP : WBEM_FLAG_SHALLOW),
NULL,
m_pObjSink);
//(IWbemObjectSink*) this);
break;
case WMI_GET_OBJ:
m_hr =
pNamespace->GetObjectAsync(
strText,
WBEM_FLAG_USE_AMENDED_QUALIFIERS,
NULL,
m_pObjSink);
//(IWbemObjectSink*) this);
break;
case WMI_ENUM_CLASS:
{
// First see if we can get the class. If we do, set m_strOpText
// to be the 'pretty' class name.
IWbemClassObject *pClass = NULL;
m_hr =
pNamespace->GetObject(
strText,
0,
NULL,
&pClass,
NULL);
if (SUCCEEDED(m_hr))
{
_variant_t var;
pClass->Get(
L"__CLASS",
0,
&var,
NULL,
NULL);
if (var.vt == VT_BSTR)
m_strOpText = var.bstrVal;
pClass->Release();
}
m_hr =
pNamespace->CreateClassEnumAsync(
strText,
//WBEM_FLAG_FORWARD_ONLY | // WMI doesn't seem to like this. Why?
WBEM_FLAG_USE_AMENDED_QUALIFIERS |
m_bOption ? WBEM_FLAG_DEEP : WBEM_FLAG_SHALLOW,
NULL,
m_pObjSink);
//(IWbemObjectSink*) this);
break;
}
case WMI_GET_CLASS:
m_hr =
pNamespace->GetObjectAsync(
strText,
WBEM_FLAG_USE_AMENDED_QUALIFIERS,
NULL,
m_pObjSink);
//(IWbemObjectSink*) this);
break;
case WMI_CREATE_CLASS:
{
BSTR bstrClass = *(LPCWSTR) strText == 0 ? NULL :
(BSTR) strText;
IWbemClassObject *pSuperClass = NULL;
// Get the superclass.
m_hr =
pNamespace->GetObject(
bstrClass,
WBEM_FLAG_USE_AMENDED_QUALIFIERS,
NULL,
&pSuperClass,
NULL);
if (SUCCEEDED(m_hr))
{
IWbemClassObject *pClass = NULL;
// If bstrClass isn't null then we didn't get a top-level
// class, which means we now need to spawn a derived class.
if (bstrClass)
{
m_hr =
pSuperClass->SpawnDerivedClass(
0,
&pClass);
if (SUCCEEDED(m_hr))
{
Indicate(1, &pClass);
// Show the user this object already needs to be saved.
m_objInfo.SetModified(TRUE);
pClass->Release();
// Fake the status callback.
SetStatus(WBEM_STATUS_COMPLETE, m_hr, NULL, NULL);
}
}
else
{
Indicate(1, &pSuperClass);
// Fake the status callback.
SetStatus(WBEM_STATUS_COMPLETE, m_hr, NULL, NULL);
}
pSuperClass->Release();
}
break;
}
case WMI_CREATE_OBJ:
{
IWbemClassObject *pClass = NULL;
// Get the superclass.
m_hr =
pNamespace->GetObject(
strText,
WBEM_FLAG_USE_AMENDED_QUALIFIERS,
NULL,
&pClass,
NULL);
if (SUCCEEDED(m_hr))
{
IWbemClassObject *pObject = NULL;
m_hr =
pClass->SpawnInstance(
0,
&pObject);
if (SUCCEEDED(m_hr))
{
Indicate(1, &pObject);
// Show the user this object already needs to be saved.
m_objInfo.SetModified(TRUE);
pObject->Release();
// Fake the status callback.
SetStatus(WBEM_STATUS_COMPLETE, m_hr, NULL, NULL);
}
pClass->Release();
}
break;
}
}
if (FAILED(m_hr))
{
IWbemClassObjectPtr pErrorObj;
pErrorObj.Attach(GetWMIErrorObject(), FALSE);
if (!m_nExpectedStatusCalls)
m_nExpectedStatusCalls = 1;
SetStatus(WBEM_STATUS_COMPLETE, m_hr, NULL, pErrorObj);
}
return m_hr;
}
HRESULT COpWrap::RefreshPropInfo(CObjInfo *pInfo)
{
if (!pInfo->IsInstance())
{
HRESULT hr = pInfo->LoadProps(m_pNamespace);
if (SUCCEEDED(hr))
AddPropsToGlobalIndex(pInfo);
return hr;
}
else
return S_OK;
}
HRESULT COpWrap::LoadPropInfo(CObjInfo *pInfo)
{
CString strClass = pInfo->GetStringPropValue(L"__CLASS");
m_cs.Lock();
CPropInfoArray *pProps;
if (!m_mapClassToProps.Lookup(strClass, pProps))
{
// Since it's not in our map it must have gotten deleted.
pInfo->SetProps(NULL);
pInfo->LoadProps(m_pNamespace);
pProps = pInfo->GetProps();
m_mapClassToProps.SetAt(strClass, pProps);
AddPropsToGlobalIndex(pInfo);
}
else
pInfo->SetProps(pProps);
m_cs.Unlock();
return S_OK;
}
HRESULT STDMETHODCALLTYPE COpWrap::Indicate(
LONG lObjectCount,
IWbemClassObject **ppObjArray)
{
for (LONG i = 0; i < lObjectCount; i++, m_nCount++)
{
CObjPtr ptr(ppObjArray[i]);
m_listObj.AddTail(ptr);
CObjInfo *pInfo;
if (!IsObject())
pInfo = new CObjInfo;
else
pInfo = &m_objInfo;
pInfo->SetObj(ppObjArray[i]);
pInfo->SetBaseImage(m_iChildImage);
LoadPropInfo(pInfo);
g_pOpView->PostMessage(WM_OBJ_INDICATE, (WPARAM) this, (LPARAM) pInfo);
}
return S_OK;
}
CString COpWrap::GetWbemErrorText(HRESULT hres)
{
CString strRet,
strError,
strFacility;
IWbemStatusCodeText *pStatus = NULL;
SCODE sc = CoCreateInstance(
CLSID_WbemStatusCodeText,
0,
CLSCTX_INPROC_SERVER,
IID_IWbemStatusCodeText,
(LPVOID *) &pStatus);
if (sc == S_OK)
{
BSTR bstr = NULL;
if (SUCCEEDED(pStatus->GetErrorCodeText(hres, 0, 0, &bstr)))
{
strError = bstr;
SysFreeString(bstr);
}
if (SUCCEEDED(pStatus->GetFacilityCodeText(hres, 0, 0, &bstr)))
{
strFacility = bstr;
SysFreeString(bstr);
}
pStatus->Release();
}
if (!strError.IsEmpty() && !strFacility.IsEmpty())
{
strRet.FormatMessage(
IDS_ERROR_FORMAT,
hres,
(LPCSTR) strFacility,
(LPCSTR) strError);
}
else
{
strRet.FormatMessage(IDS_ERROR_FAILED, hres);
}
return strRet;
}
HRESULT STDMETHODCALLTYPE COpWrap::SetStatus(
LONG lFlags,
HRESULT hResult,
BSTR strParam,
IWbemClassObject *pObjParam)
{
if (m_nExpectedStatusCalls)
{
m_status = lFlags;
m_hr = hResult;
if (SUCCEEDED(hResult))
m_strErrorText.Empty();
else
m_strErrorText = GetWbemErrorText(hResult);
g_pOpView->PostMessage(WM_OP_STATUS, (WPARAM) this, 0);
m_nExpectedStatusCalls--;
m_pErrorObj = pObjParam;
}
return S_OK;
}
void COpWrap::SetHoldsObjects()
{
switch(m_type)
{
case WMI_QUERY:
{
CString strQuery = m_strOpText;
strQuery.MakeUpper();
strQuery.TrimLeft();
if (strQuery.Find(_T("ASSOCIATORS")) != -1 ||
strQuery.Find(_T("REFERENCES")) != -1)
m_bShowPathsOnly = TRUE;
else
m_bShowPathsOnly = FALSE;
break;
}
case WMI_ENUM_OBJ:
case WMI_GET_OBJ:
case WMI_EVENT_QUERY:
case WMI_CREATE_OBJ:
m_bShowPathsOnly = FALSE;
break;
default:
case WMI_ENUM_CLASS:
case WMI_GET_CLASS:
case WMI_CREATE_CLASS:
m_bShowPathsOnly = TRUE;
}
}
void COpWrap::GetPropValue(
CObjInfo *pInfo,
int iGlobalIndex,
CString &strValue,
BOOL bTranslate)
{
int iIndex;
if (pInfo->GetProps()->m_mapGlobalToLocalIndex.Lookup(iGlobalIndex, iIndex))
pInfo->GetPropValue(iIndex, strValue, bTranslate);
}
CString COpWrap::GetClassName()
{
CString strRet;
if (m_type != WMI_ENUM_CLASS)
{
if (m_listObj.GetCount())
{
CObjPtr &pObj = m_listObj.GetAt(m_listObj.GetHeadPosition());
_variant_t var;
if (SUCCEEDED(pObj->Get(
L"__CLASS",
0,
&var,
NULL,
NULL)) && var.vt == VT_BSTR)
{
strRet = var.bstrVal;
}
}
}
else
{
return m_strOpText;
}
return strRet;
}
CString COpWrap::GetCaption()
{
CString strRet;
switch(m_type)
{
case WMI_CREATE_CLASS:
if (!m_strOpText.IsEmpty())
strRet.Format(IDS_SUBCLASS_OF, (LPCTSTR) m_strOpText);
else
strRet.LoadString(IDS_TOPLEVEL_CLASS);
break;
case WMI_GET_CLASS:
strRet = GetClassName();
if (strRet.IsEmpty())
strRet = m_strOpText;
break;
case WMI_ENUM_CLASS:
if (!m_strOpText.IsEmpty())
strRet.Format(IDS_ENUM_CLASS_CAPTION, (LPCTSTR) m_strOpText);
else
strRet.LoadString(m_bOption ? IDS_ALL_CLASSES :
IDS_TOP_LEVEL_CLASSES);
break;
case WMI_GET_OBJ:
case WMI_EVENT_QUERY:
case WMI_QUERY:
strRet = m_strOpText;
break;
case WMI_CREATE_OBJ:
strRet.Format(IDS_INSTANCE_OF, (LPCTSTR) m_strOpText);
break;
case WMI_ENUM_OBJ:
{
CString strClass = GetClassName();
if (strClass.IsEmpty())
strClass = m_strOpText;
strRet.Format(IDS_ENUM_OBJ_CAPTION, (LPCTSTR) strClass);
break;
}
}
return strRet;
}
#define DEF_MAX_COLS 100
#define DEF_COL_SIZE 100
int COpWrap::GetPropIndex(LPCTSTR szName, BOOL bAddToDisplay)
{
for (int i = 0; i <= m_strProps.GetUpperBound(); i++)
{
if (m_strProps[i] == szName)
return i;
}
m_strProps.Add(szName);
if (bAddToDisplay)
{
m_piDisplayCols.Add(i);
if (m_piDisplayCols.GetUpperBound() >
m_piDisplayColsWidth.GetUpperBound())
{
m_piDisplayColsWidth.Add(DEF_COL_SIZE);
}
}
return i;
}
void COpWrap::AddPropsToGlobalIndex(CObjInfo *pInfo)
{
CPropInfoArray *ppProps = pInfo->GetProps();
if (ppProps)
{
CPropInfo *pProps = ppProps->GetData();
int nItems = ppProps->GetSize();
for (int i = 0; i < nItems; i++)
{
int iGlobalIndex = GetPropIndex(pProps[i].m_strName,
!(pProps[i].m_iFlavor == WBEM_FLAVOR_ORIGIN_SYSTEM));
ppProps->m_mapGlobalToLocalIndex.SetAt(iGlobalIndex, i);
}
}
}
void CPropInfoArray::LoadMethods(IWbemClassObject *pClass)
{
HRESULT hr;
// Flush the list.
while(m_listMethods.GetCount())
m_listMethods.RemoveHead();
m_nStaticMethods = 0;
if (pClass && SUCCEEDED(hr = pClass->BeginMethodEnumeration(0)))
{
BSTR pName = NULL;
while(1)
{
hr =
pClass->NextMethod(
0,
&pName,
NULL,
NULL);
if (FAILED(hr) || hr == WBEM_S_NO_MORE_DATA)
break;
IWbemQualifierSetPtr pQuals;
CMethodInfo method;
method.m_strName = pName;
SysFreeString(pName);
if (SUCCEEDED(hr = pClass->GetMethodQualifierSet(
pName,
&pQuals)))
{
_variant_t vStatic;
if (SUCCEEDED(hr = pQuals->Get(
L"static",
0,
&vStatic,
NULL)) && vStatic.vt == VT_BOOL && (bool) vStatic == true)
{
method.m_bStatic = TRUE;
m_nStaticMethods++;
}
_variant_t vDesc;
if (SUCCEEDED(hr = pQuals->Get(
L"Description",
0,
&vDesc,
NULL)) && vDesc.vt == VT_BSTR)
{
method.m_strDescription = vDesc.bstrVal;
}
m_listMethods.AddTail(method);
}
}
}
}
int COpWrap::GetImage()
{
if (m_status == WBEM_STATUS_PROGRESS)
return m_iImageBase + 1; // + 1 == busy
else
{
if (SUCCEEDED(m_hr))
// If we're an object, use our m_objInfo to get the image.
return IsObject() ? m_objInfo.GetImage() : m_iImageBase;
else
// + 2 == error
return m_iImageBase + 2;
}
}
void COpWrap::CancelOp(IWbemServices *pNamespace)
{
if (m_status == WBEM_STATUS_PROGRESS)
{
HRESULT hr;
if (FAILED(hr = pNamespace->CancelAsyncCall(m_pObjSink)))
{
//((IWbemObjectSink*) this)->Release();
SetStatus(
WBEM_STATUS_COMPLETE,
hr,
NULL,
NULL);
}
}
}
IMPLEMENT_SERIAL(COpWrap, CObject, VERSIONABLE_SCHEMA|1)
void COpWrap::Serialize(CArchive &archive)
{
if (archive.IsLoading())
{
int type;
archive >> type;
m_type = (WMI_OP_TYPE) type;
archive >> m_strOpText;
archive >> m_bOption;
int nCols;
archive >> nCols;
if (nCols > 0)
{
m_piDisplayColsWidth.SetSize(nCols);
for (int i = 0; i < nCols; i++)
{
int iVal;
archive >> iVal;
m_piDisplayColsWidth[i] = iVal;
}
}
Init();
}
else
{
archive.SetObjectSchema(1);
archive << (int) m_type;
archive << m_strOpText;
archive << m_bOption;
int nCols = m_piDisplayColsWidth.GetUpperBound() + 1;
archive << nCols;
for (int i = 0; i < nCols; i++)
archive << m_piDisplayColsWidth[i];
}
}
void COpWrap::Init()
{
m_hr = S_OK;
SetHoldsObjects();
switch(m_type)
{
case WMI_QUERY:
m_iImageBase = IMAGE_QUERY;
m_iChildImage = IMAGE_OBJECT;
break;
case WMI_ENUM_OBJ:
m_iImageBase = IMAGE_ENUM_OBJ;
m_iChildImage = IMAGE_OBJECT;
break;
case WMI_CREATE_OBJ:
case WMI_GET_OBJ:
m_iImageBase = IMAGE_OBJECT;
m_iChildImage = IMAGE_OBJECT;
break;
case WMI_EVENT_QUERY:
m_iImageBase = IMAGE_EVENT_QUERY;
m_iChildImage = IMAGE_OBJECT;
break;
case WMI_ENUM_CLASS:
m_iImageBase = IMAGE_ENUM_CLASS;
m_iChildImage = IMAGE_CLASS;
break;
case WMI_CREATE_CLASS:
case WMI_GET_CLASS:
m_iImageBase = IMAGE_CLASS;
m_iChildImage = IMAGE_CLASS;
break;
}
}
/////////////////////////////////////////////////////////////////////////////
// CClassToProps
CClassToProps::~CClassToProps()
{
Flush();
}
void CClassToProps::Flush()
{
POSITION pos = GetStartPosition();
CPropInfoArray *pProps;
CString strClass;
while (pos)
{
GetNextAssoc(pos, strClass, pProps);
delete pProps;
}
RemoveAll();
}
/////////////////////////////////////////////////////////////////////////////
// CPropInfo
// Copy constructor.
CPropInfo::CPropInfo(const CPropInfo& other)
{
*this = other;
}
const CPropInfo& CPropInfo::operator=(const CPropInfo& other)
{
m_strName = other.m_strName;
m_iHandle = other.m_iHandle;
m_type = other.m_type;
m_iFlavor = other.m_iFlavor;
m_bKey = other.m_bKey;
m_dwExpectedSize = other.m_dwExpectedSize;
m_vt = other.m_vt;
m_bSigned = other.m_bSigned;
m_bValueMap = other.m_bValueMap;
m_bBitmask = other.m_bBitmask;
// Copy the m_mapValues member.
POSITION pos = other.m_mapValues.GetStartPosition();
m_mapValues.RemoveAll();
while (pos)
{
CString strKey,
strValue;
other.m_mapValues.GetNextAssoc(pos, strKey, strValue);
m_mapValues.SetAt(strKey, strValue);
}
// Copy the m_bitmaskValues member.
int nItems = other.m_bitmaskValues.GetSize();
m_bitmaskValues.SetSize(nItems);
for (int i = 0; i < nItems; i++)
m_bitmaskValues[i] = other.m_bitmaskValues[i];
return *this;
}
void CPropInfo::SetType(CIMTYPE type)
{
m_type = type;
m_bSigned = FALSE;
switch(m_type & ~CIM_FLAG_ARRAY)
{
default:
case CIM_EMPTY:
m_dwExpectedSize = 0;
//m_dwArrayItemSize = 0;
m_vt = VT_EMPTY;
break;
case CIM_SINT8:
m_bSigned = TRUE;
m_dwExpectedSize = 1;
// Fall through...
case CIM_UINT8:
m_dwExpectedSize = 1;
//m_dwArrayItemSize = 1;
m_vt = VT_UI1;
break;
case CIM_SINT16:
m_bSigned = TRUE;
// Fall through...
case CIM_CHAR16:
case CIM_UINT16:
m_dwExpectedSize = 2;
//m_dwArrayItemSize = 4;
m_vt = VT_I2;
break;
case CIM_SINT64:
m_bSigned = TRUE;
// Fall through...
case CIM_UINT64:
m_dwExpectedSize = sizeof(__int64);
//m_dwArrayItemSize = sizeof(__int64);
m_vt = VT_I8;
break;
case CIM_REAL32:
m_dwExpectedSize = sizeof(float);
//m_dwArrayItemSize = sizeof(float);
m_vt = VT_R4;
break;
case CIM_REAL64:
m_dwExpectedSize = sizeof(double);
//m_dwArrayItemSize = sizeof(double);
m_vt = VT_R8;
break;
case CIM_BOOLEAN:
m_dwExpectedSize = sizeof(short);
//m_dwArrayItemSize = sizeof(short);
m_vt = VT_BOOL;
break;
case CIM_STRING:
case CIM_DATETIME:
case CIM_REFERENCE:
m_dwExpectedSize = MAX_STR_SIZE;
//m_dwArrayItemSize = sizeof(BSTR*);
m_vt = VT_BSTR;
break;
case CIM_OBJECT:
m_dwExpectedSize = sizeof(LPVOID);
//m_dwArrayItemSize = sizeof(BSTR*);
m_vt = VT_UNKNOWN;
break;
case CIM_SINT32:
m_bSigned = TRUE;
// Fall through...
case CIM_UINT32:
m_dwExpectedSize = sizeof(DWORD);
//m_dwArrayItemSize = sizeof(DWORD);
m_vt = VT_I4;
break;
}
if (m_type & CIM_FLAG_ARRAY)
m_vt = (VARENUM) ((int) m_vt | VT_ARRAY);
}
void CPropInfo::GetPropType(
CString &strType,
int *piImage,
BOOL bIgnoreArrayFlag)
{
DWORD dwStrID;
*piImage = IMAGE_PROP_BINARY;
switch(m_type & ~CIM_FLAG_ARRAY)
{
default:
case CIM_EMPTY:
dwStrID = IDS_CIM_EMPTY;
break;
case CIM_SINT8:
dwStrID = IDS_CIM_SINT8;
break;
case CIM_UINT8:
dwStrID = IDS_CIM_UINT8;
break;
case CIM_SINT16:
dwStrID = IDS_CIM_SINT16;
break;
case CIM_UINT16:
dwStrID = IDS_CIM_UINT16;
break;
case CIM_SINT64:
dwStrID = IDS_CIM_SINT64;
break;
case CIM_UINT64:
dwStrID = IDS_CIM_UINT64;
break;
case CIM_REAL32:
dwStrID = IDS_CIM_REAL32;
break;
case CIM_REAL64:
dwStrID = IDS_CIM_REAL64;
break;
case CIM_BOOLEAN:
dwStrID = IDS_CIM_BOOLEAN;
break;
case CIM_DATETIME:
dwStrID = IDS_CIM_DATETIME;
break;
case CIM_REFERENCE:
dwStrID = IDS_CIM_REFERENCE;
*piImage = IMAGE_PROP_OBJECT;
break;
case CIM_CHAR16:
dwStrID = IDS_CIM_CHAR16;
break;
case CIM_OBJECT:
dwStrID = IDS_CIM_OBJECT;
break;
case CIM_STRING:
dwStrID = IDS_CIM_STRING;
*piImage = IMAGE_PROP_TEXT;
break;
case CIM_UINT32:
dwStrID = IDS_CIM_UINT32;
break;
case CIM_SINT32:
dwStrID = IDS_CIM_SINT32;
break;
}
strType.LoadString(dwStrID);
if ((m_type & CIM_FLAG_ARRAY) && !bIgnoreArrayFlag)
{
CString strArray;
strArray.LoadString(IDS_CIM_ARRAY);
strType += _T(" | ");
strType += strArray;
}
if (m_bKey)
*piImage = *piImage + 1;
}
DWORD64 ato64u(LPCTSTR szVal)
{
DWORD64 dwRet = 0;
_stscanf(szVal, _T("%I64u"), &dwRet);
return dwRet;
}
BOOL CPropInfo::SetArrayItem(VARIANT *pVar, DWORD dwIndex, DWORD dwValue)
{
ASSERT(m_vt & VT_ARRAY);
ASSERT(pVar->vt & VT_ARRAY);
ASSERT(dwIndex < pVar->parray->rgsabound[0].cElements);
DWORD dwArrayItemSize = GetArrayItemSize((VARENUM) pVar->vt);
LPBYTE pDest = (LPBYTE) pVar->parray->pvData + (dwArrayItemSize * dwIndex);
BOOL bRet = TRUE;
switch(dwArrayItemSize)
{
case 1:
*(char*) pDest = dwValue;
break;
case 2:
*(short*) pDest = dwValue;
break;
case 4:
*(int*) pDest = dwValue;
break;
default:
bRet = FALSE;
}
return bRet;
}
DWORD CPropInfo::GetArrayItem(VARIANT *pVar, DWORD dwIndex)
{
ASSERT(m_vt & VT_ARRAY);
ASSERT(pVar->vt & VT_ARRAY);
ASSERT(dwIndex < pVar->parray->rgsabound[0].cElements);
DWORD dwArrayItemSize = GetArrayItemSize((VARENUM) pVar->vt);
LPBYTE pSrc = (LPBYTE) pVar->parray->pvData +
(dwArrayItemSize * dwIndex);
DWORD dwRet = 0;
switch(dwArrayItemSize)
{
case 1:
dwRet = *(char*) pSrc;
break;
case 2:
dwRet = *(short*) pSrc;
break;
case 4:
dwRet = *(int*) pSrc;
break;
}
return dwRet;
}
// This one doesn't handle arrays since we'll never go from a single string to
// an array.
BOOL CPropInfo::StringToVariant(LPCSTR szValue, VARIANT *pVar, BOOL bTranslate)
{
BOOL bRet;
VARENUM typeRaw = (VARENUM) (m_vt & ~VT_ARRAY);
VariantClear(pVar);
pVar->vt = typeRaw;
if (pVar->vt == VT_I8)
pVar->vt = VT_BSTR;
LPVOID pData = &V_BSTR(pVar);
bRet = StringToVariantBlob(szValue, pData, bTranslate);
return bRet;
}
// TODO: Need to be able to accept dates with month names.
LPTSTR IntToDMTF(LPTSTR szOut, int iValue, int iDigits)
{
_ASSERT(iDigits <= 6 && iDigits >= 0);
if (iValue == -1)
{
memcpy(szOut, _T("******"), iDigits * sizeof(TCHAR));
szOut[iDigits] = 0;
}
else
{
char szFormat[100] = _T("%0*d");
szFormat[2] = '0' + iDigits;
wsprintf(szOut, szFormat, iValue);
}
return szOut;
}
enum LOCALE_TOKEN
{
L_UNKNOWN,
L_MONTH_1,
L_MONTH_2,
L_MONTH_3,
L_MONTH_4,
L_MONTH_5,
L_MONTH_6,
L_MONTH_7,
L_MONTH_8,
L_MONTH_9,
L_MONTH_10,
L_MONTH_11,
L_MONTH_12,
L_DATE_SEP,
L_TIME_SEP,
L_AM,
L_PM,
L_UTC
};
class CLocaleInfo
{
public:
TCHAR szDateSep[MAX_PATH],
szTimeSep[MAX_PATH],
szPM[MAX_PATH],
szAM[MAX_PATH],
szUTC[MAX_PATH],
szLongMonths[12][MAX_PATH],
szShortMonths[12][MAX_PATH];
CLocaleInfo() { Init(); }
void Init();
LOCALE_TOKEN GetNextToken(LPCTSTR *ppszCurrent);
protected:
BOOL CheckAndIncrement(LPCTSTR szCheckAgainst, LPCTSTR *ppszCurrent);
};
LOCALE_TOKEN CLocaleInfo::GetNextToken(LPCTSTR *ppszCurrent)
{
if (CheckAndIncrement(szDateSep, ppszCurrent))
return L_DATE_SEP;
else if (CheckAndIncrement(szTimeSep, ppszCurrent))
return L_TIME_SEP;
else if (CheckAndIncrement(szAM, ppszCurrent))
return L_AM;
else if (CheckAndIncrement(szPM, ppszCurrent))
return L_PM;
else if (CheckAndIncrement(szUTC, ppszCurrent))
return L_UTC;
else
{
for (int i = 0; i < 12; i++)
{
if (CheckAndIncrement(szLongMonths[i], ppszCurrent))
return (LOCALE_TOKEN) (L_MONTH_1 + i);
}
for (i = 0; i < 12; i++)
{
if (CheckAndIncrement(szShortMonths[i], ppszCurrent))
return (LOCALE_TOKEN) (L_MONTH_1 + i);
}
}
return L_UNKNOWN;
}
BOOL CLocaleInfo::CheckAndIncrement(LPCTSTR szCheckAgainst, LPCTSTR *ppszCurrent)
{
// Get past the spaces.
while (isspace(**ppszCurrent))
(*ppszCurrent)++;
int nLen = _tcslen(szCheckAgainst);
BOOL bRet;
if (!_tcsncmp(szCheckAgainst, *ppszCurrent, nLen))
{
bRet = TRUE;
*ppszCurrent += nLen;
}
else
bRet = FALSE;
return bRet;
}
void CLocaleInfo::Init()
{
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_SDATE,
szDateSep,
sizeof(szDateSep) / sizeof(TCHAR));
_tcsupr(szDateSep);
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_STIME,
szTimeSep,
sizeof(szTimeSep) / sizeof(TCHAR));
_tcsupr(szTimeSep);
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_S2359,
szPM,
sizeof(szPM) / sizeof(TCHAR));
_tcsupr(szPM);
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_S1159,
szAM,
sizeof(szAM) / sizeof(TCHAR));
_tcsupr(szAM);
for (int i = 0; i < 12; i++)
{
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_SMONTHNAME1 + i,
szLongMonths[i],
sizeof(szLongMonths[0]) / sizeof(TCHAR));
_tcsupr(szLongMonths[i]);
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_SABBREVMONTHNAME1 + i,
szShortMonths[i],
sizeof(szShortMonths[0]) / sizeof(TCHAR));
_tcsupr(szShortMonths[i]);
}
CString strUTC;
strUTC.LoadString(IDS_UTC_TOKEN);
lstrcpy(szUTC, strUTC);
}
enum DATE_STATE
{
S_BEGIN,
S_MONTH,
S_DAY,
S_YEAR,
S_HOUR,
S_MINUTE,
S_SECOND,
S_NEED_UTC,
};
BOOL DoAMPM(LOCALE_TOKEN token, int *piHour, DATE_STATE *pState)
{
BOOL bRet;
ASSERT(*piHour != -1);
if (*pState == S_HOUR || *pState == S_MINUTE || *pState == S_SECOND)
{
bRet = TRUE;
if (*piHour == 12 && token == L_AM)
*piHour = 0;
else if (*piHour < 12 && token == L_PM)
*piHour += 12;
*pState = S_NEED_UTC;
}
else
bRet = FALSE;
return bRet;
}
BOOL DoUTC(int *piOffset, LPCTSTR *pszCurrent, TCHAR *pcOffsetSign, DATE_STATE *pState)
{
// Until we prove otherwise...
BOOL bRet = FALSE;
TCHAR cSign = **pszCurrent;
if (cSign == '+' || cSign == '-')
{
// Get past the sign.
(*pszCurrent)++;
if (isdigit(**pszCurrent))
{
*piOffset = _ttoi(*pszCurrent) * 60;
// Get past the number.
while (isdigit(**pszCurrent))
(*pszCurrent)++;
if (**pszCurrent != ')')
{
// Get past the separator.
while (!isdigit(**pszCurrent) && **pszCurrent)
(*pszCurrent)++;
*piOffset += _ttoi(*pszCurrent);
}
// Find the end of this thing.
while (**pszCurrent != ')' && **pszCurrent)
(*pszCurrent)++;
if (**pszCurrent == ')')
{
*pcOffsetSign = cSign;
*pState = S_BEGIN;
(*pszCurrent)++;
bRet = TRUE;
}
}
}
return bRet;
}
BOOL StringDateTimeToDMTF(LPCTSTR szDateTime, CString &strDateTime)
{
CLocaleInfo info;
DATE_STATE state = S_BEGIN;
BOOL bMonthFromString = FALSE,
bPM = FALSE,
bAM = FALSE;
int iDay = -1,
iMonth = -1,
iYear = -1,
iHour = -1,
iMin = -1,
iSec = -1,
iMicro = -1,
iOffset = -1;
char szOffsetSign[2] = _T("*");
BOOL bRet = TRUE;
CString strTemp = szDateTime;
// So we can do case insensitive compares.
strTemp.MakeUpper();
LPCTSTR szCurrent = strTemp;
while (*szCurrent && bRet)
{
while (isspace(*szCurrent))
szCurrent++;
////////////////////////////////////////////////////
// State action == number found
if (isdigit(*szCurrent))
{
// Reset if we were potentially looking for a UTC and we didn't get it.
if (state == S_NEED_UTC)
state = S_BEGIN;
int iNumber = _ttoi(szCurrent);
// Get past the current number.
while (isdigit(*szCurrent))
szCurrent++;
LOCALE_TOKEN token = info.GetNextToken(&szCurrent);
switch(state)
{
////////////////////////////////////////////////////
// Begin state
case S_BEGIN:
if (token == L_TIME_SEP)
{
iHour = iNumber;
state = S_HOUR;
}
else if (token == L_DATE_SEP || token == L_UNKNOWN)
{
iMonth = iNumber;
state = S_MONTH;
}
else if (token == L_AM || token == L_PM)
{
iHour = iNumber;
state = S_HOUR;
bRet = DoAMPM(token, &iHour, &state);
//bAM = token == L_AM;
//bPM = !bAM;
//state = S_NEED_UTC;
}
else
bRet = FALSE;
break;
////////////////////////////////////////////////////
// Date states
case S_MONTH:
if (token == L_DATE_SEP)
{
iDay = iNumber;
state = S_DAY;
}
else if (token == L_UNKNOWN)
{
iYear = iNumber;
state = S_BEGIN;
}
else
bRet = FALSE;
break;
case S_DAY:
if (token == L_UNKNOWN)
{
iYear = iNumber;
state = S_BEGIN;
}
else
bRet = FALSE;
break;
//case S_YEAR:
// iYear = iNumber;
// state = S_BEGIN;
// break;
////////////////////////////////////////////////////
// Time states
case S_HOUR:
iMin = iNumber;
if (token == L_TIME_SEP)
state = S_MINUTE;
else if (token == L_AM || token == L_PM)
bRet = DoAMPM(token, &iHour, &state);
else if (token == L_UTC)
bRet = DoUTC(&iOffset, &szCurrent, &szOffsetSign[0], &state);
else
bRet = FALSE;
break;
case S_MINUTE:
iSec = iNumber;
if (token == L_AM || token == L_PM)
bRet = DoAMPM(token, &iHour, &state);
else if (token == L_UTC)
bRet = DoUTC(&iOffset, &szCurrent, &szOffsetSign[0], &state);
else
bRet = FALSE;
break;
default:
bRet = FALSE;
break;
}
} // End of state action == number found.
else
{
////////////////////////////////////////////////////
// State action == some token
LOCALE_TOKEN token = info.GetNextToken(&szCurrent);
// Reset if we were potentially looking for a UTC and we didn't get it.
if (state == S_NEED_UTC && token != L_UTC)
state = S_BEGIN;
// token == string month found
if (token >= L_MONTH_1 && token <= L_MONTH_12)
{
// Move past any non-digits beyond the string date, such as a
// separator or a comma, etc.
while (!isdigit(*szCurrent) && *szCurrent)
szCurrent++;
if (state == S_BEGIN)
{
iMonth = token - L_MONTH_1 + 1;
state = S_MONTH;
bMonthFromString = TRUE;
}
else if (state == S_MONTH && !bMonthFromString)
{
iDay = iMonth;
iMonth = token - L_MONTH_1 + 1;
state = S_DAY;
}
else
bRet = FALSE;
}
else if (token == L_AM || token == L_PM)
{
if (state == S_HOUR || state == S_MINUTE || state == S_SECOND)
{
//bAM = token == L_AM;
//bPM = !bAM;
bRet = DoAMPM(token, &iHour, &state);
//state = S_NEED_UTC;
}
else
bRet = FALSE;
}
else if (state == S_NEED_UTC)
{
bRet = DoUTC(&iOffset, &szCurrent, &szOffsetSign[0], &state);
}
else if (token == L_UNKNOWN)
szCurrent++;
else
bRet = FALSE;
}
}
// At this point, we may need to juggle our day and month around, depending
// on what the order is for the current locale.
if (iDay != -1 && iMonth != -1 && iYear != -1)
{
TCHAR szOrder[2] = _T("0");
GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_IDATE,
szOrder,
sizeof(szOrder) / sizeof(TCHAR));
// dd/mm/yy
if (*szOrder == '1')
{
int iTemp = iDay;
iDay = iMonth;
iMonth = iDay;
}
// yy/mm/dd
else if (*szOrder == '2')
{
int iTemp = iDay;
iDay = iYear;
iYear = iDay;
}
}
// Finally, splice it all together.
TCHAR szOut[100] = _T(""),
szTemp[20];
lstrcat(szOut, IntToDMTF(szTemp, iYear, 4));
lstrcat(szOut, IntToDMTF(szTemp, iMonth, 2));
lstrcat(szOut, IntToDMTF(szTemp, iDay, 2));
lstrcat(szOut, IntToDMTF(szTemp, iHour, 2));
lstrcat(szOut, IntToDMTF(szTemp, iMin, 2));
lstrcat(szOut, IntToDMTF(szTemp, iSec, 2));
lstrcat(szOut, _T("."));
lstrcat(szOut, IntToDMTF(szTemp, iMicro, 6));
lstrcat(szOut, szOffsetSign);
lstrcat(szOut, IntToDMTF(szTemp, iOffset, 3));
strDateTime = szOut;
return TRUE;
}
BOOL IsDMTF(LPCTSTR szDate)
{
for (int i = 0; i < 14; i++)
{
if (!isdigit(szDate[i]) && szDate[i] != '*')
return FALSE;
}
if (szDate[14] != '.')
return FALSE;
for (i = 15; i < 21; i++)
{
if (!isdigit(szDate[i]) && szDate[i] != '*')
return FALSE;
}
if (szDate[21] != '-' && szDate[21] != '+' && szDate[21] != '*')
return FALSE;
for (i = 22; i < 25; i++)
{
if (!isdigit(szDate[i]) && szDate[i] != '*')
return FALSE;
}
return TRUE;
}
BOOL CPropInfo::StringToVariantBlob(LPCTSTR szValue, LPVOID pData,
BOOL bTranslate)
{
BOOL bRet = TRUE;
char *szTemp;
CString strValue;
VARENUM typeRaw = (VARENUM) (m_vt & ~VT_ARRAY);
// This one is special-cased from the others because the value will
// usually be in a localized form, even if bTranslate == FALSE.
if (typeRaw == VT_BOOL)
{
CString strTrue;
strTrue.LoadString(IDS_TRUE);
if (!lstrcmpi(strTrue, szValue))
*(short*) pData = VARIANT_TRUE;
else
*(short*) pData = atoi(szValue) ? VARIANT_TRUE : VARIANT_FALSE;
}
else
{
// Translate if necessary.
if (bTranslate && m_bValueMap)
{
// TODO: We could make this faster if we added a reverse lookup
// map. For now we'll do a sequential search.
POSITION pos = m_mapValues.GetStartPosition();
CString strKey;
while(pos)
{
m_mapValues.GetNextAssoc(pos, strKey, strValue);
if (!lstrcmpi(szValue, strValue))
{
szValue = strKey;
break;
}
}
}
switch(typeRaw)
{
case VT_I8:
case VT_BSTR:
{
if (GetRawCIMType() != CIM_DATETIME)
*(BSTR*) pData = _bstr_t(szValue).copy();
else
{
if (!IsDMTF(szValue))
{
CString strRet;
StringDateTimeToDMTF(szValue, strRet);
_ASSERT(IsDMTF(strRet));
*(BSTR*) pData = strRet.AllocSysString();
}
else
*(BSTR*) pData = _bstr_t(szValue).copy();
}
break;
}
case VT_R8:
*(double*) pData = atof(szValue);
break;
case VT_R4:
*(float*) pData = atof(szValue);
break;
case VT_UI1:
*(char*) pData = m_bSigned ? atoi(szValue) : strtoul(szValue, &szTemp, 10);
break;
case VT_I2:
*(short*) pData = m_bSigned ? atoi(szValue) : strtoul(szValue, &szTemp, 10);
break;
case VT_I4:
*(int*) pData = m_bSigned ? atoi(szValue) : strtoul(szValue, &szTemp, 10);
break;
//case VT_I8:
// *(DWORD64*) pData = m_bSigned ? _atoi64(szValue) : ato64u(szValue);
// break;
}
}
return bRet;
}
// We have to pass the vt as contained on the actual variant because WMI sometimes
// uses a different VARENUM for Gets/Puts (go figure).
BOOL CPropInfo::VariantBlobToString(VARENUM vt, LPVOID pData, CString &strValue,
BOOL bTranslate, BOOL bQuoteStrings)
{
VARENUM vtRaw = (VARENUM) (vt & ~VT_ARRAY);
strValue.Empty();
switch(vtRaw)
{
case VT_BSTR:
strValue = *(BSTR*) pData;
break;
case VT_R8:
strValue.Format(_T("%.5f"), *(double*) pData);
break;
case VT_R4:
strValue.Format(_T("%.5f"), *(float*) pData);
break;
case VT_UI1:
{
if (m_bSigned)
strValue.Format(_T("%d"), *(char*) pData);
else
strValue.Format(_T("%u"), *(BYTE*) pData);
break;
}
case VT_I2:
{
if (m_bSigned)
strValue.Format(_T("%d"), *(short*) pData);
else
strValue.Format(_T("%u"), *(WORD*) pData);
break;
}
case VT_I4:
{
if (m_bSigned)
strValue.Format(_T("%d"), *(int*) pData);
else
strValue.Format(_T("%u"), *(DWORD*) pData);
break;
}
case VT_I8:
{
if (m_bSigned)
strValue.Format(_T("%I64d"), *(__int64*) pData);
else
strValue.Format(_T("%I64u"), *(DWORD64*) pData);
break;
}
case VT_BOOL:
strValue.LoadString(*(short*) pData ? IDS_TRUE : IDS_FALSE);
break;
case VT_UNKNOWN:
//strValue.Format(IDS_EMBEDDED_OBJECT, *(IUnknown*) pData);
strValue = GetEmbeddedObjectText(*(IUnknown**) pData);
break;
}
if (bTranslate && !strValue.IsEmpty())
{
if (m_bValueMap)
{
CString strKey = strValue;
m_mapValues.Lookup(strKey, strValue);
}
else if (m_bBitmask)
{
DWORD nSize = m_bitmaskValues.GetSize(),
dwValue = *(DWORD*) pData;
// Clear this out.
strValue.Empty();
for (int i = 0; i < nSize; i++)
{
CString strPart;
if (dwValue & m_bitmaskValues[i].m_dwBitmaskValue)
{
if (!strValue.IsEmpty())
strValue += _T(" | ");
strValue += m_bitmaskValues[i].m_strName;
}
}
}
else if (GetRawCIMType() == CIM_DATETIME)
{
struct DATETIME_INFO
{
TCHAR szYear[5],
szMonth[3],
szDay[3],
szHour[3],
szMin[3],
szSec[3],
szMicro[7],
cSep,
szOffset[4];
} datetime;
ZeroMemory(&datetime, sizeof(datetime));
if (_stscanf(
strValue,
_T("%4c%2c%2c%2c%2c%2c.%6c%c%3c"),
datetime.szYear,
datetime.szMonth,
datetime.szDay,
datetime.szHour,
datetime.szMin,
datetime.szSec,
datetime.szMicro,
&datetime.cSep,
datetime.szOffset) == 9)
{
SYSTEMTIME systime;
TCHAR szDate[100] = _T(""),
szTime[100] = _T("");
// _stscanf seems to be screwing this up, so fix it.
datetime.szOffset[3] = 0;
ZeroMemory(&systime, sizeof(systime));
// Figure out the date.
if (*datetime.szYear != '*' && *datetime.szMonth != '*')
{
DWORD dwFlag;
TCHAR szFormat[10],
*pszFormat;
systime.wYear = (WORD) _ttoi(datetime.szYear);
systime.wMonth = (WORD) _ttoi(datetime.szMonth);
if (*datetime.szDay == '*')
{
// This would have been nice to use, but it only lives
// on W2K.
//dwFlag = DATE_YEARMONTH;
TCHAR szSep[100];
if (GetLocaleInfo(
LOCALE_USER_DEFAULT,
LOCALE_SDATE,
szSep,
sizeof(szSep) / sizeof(TCHAR)))
{
// Otherwise GetDateFormat will fail, even though
// it doesn't need it!
systime.wDay = 1;
wsprintf(szFormat, _T("MM%syyyy"), szSep);
dwFlag = 0;
pszFormat = szFormat;
}
}
else
{
dwFlag = DATE_SHORTDATE;
pszFormat = NULL;
systime.wDay = (WORD) _ttoi(datetime.szDay);
}
GetDateFormat(
LOCALE_USER_DEFAULT,
dwFlag,
&systime,
pszFormat,
szDate,
sizeof(szDate) / sizeof(TCHAR));
}
// Figure out the time.
if (*datetime.szHour != '*')
{
DWORD dwFlag = 0;
systime.wHour = (WORD) _ttoi(datetime.szHour);
if (*datetime.szMin == '*')
dwFlag = TIME_NOMINUTESORSECONDS;
else
{
systime.wMinute = (WORD) _ttoi(datetime.szMin);
if (*datetime.szSec == '*')
dwFlag = TIME_NOSECONDS;
else
systime.wSecond = (WORD) _ttoi(datetime.szSec);
}
GetTimeFormat(
LOCALE_USER_DEFAULT,
dwFlag,
&systime,
NULL,
szTime,
sizeof(szTime) / sizeof(TCHAR));
if (*szTime &&
(datetime.cSep == '-' || datetime.cSep == '+') &&
*datetime.szOffset != '*')
{
CString strOffset;
DWORD dwMinutes = _ttoi(datetime.szOffset);
strOffset.FormatMessage(
IDS_UTC, datetime.cSep, dwMinutes / 60,
dwMinutes % 60);
strcat(szTime, strOffset);
}
}
strValue = szDate;
if (*szTime)
{
if (!strValue.IsEmpty())
strValue += _T(" ");
strValue += szTime;
}
}
}
}
if (bQuoteStrings && GetRawCIMType() == CIM_STRING)
{
CString strTemp;
strTemp.Format(_T("\"%s\""), (LPCTSTR) strValue);
strValue = strTemp;
}
return TRUE;
}
DWORD CPropInfo::GetArrayItemCount(VARIANT *pVar)
{
return pVar->parray->rgsabound[0].cElements;
}
BOOL CPropInfo::ArrayItemToString(VARIANT *pVar, DWORD dwIndex,
CString &strValue, BOOL bTranslate)
{
ASSERT(m_vt & VT_ARRAY);
ASSERT(pVar->vt & VT_ARRAY);
ASSERT(dwIndex < pVar->parray->rgsabound[0].cElements);
BOOL bRet = TRUE;
LPBYTE pData = (LPBYTE) pVar->parray->pvData;
CString strItem;
DWORD dwArrayItemSize = GetArrayItemSize((VARENUM) pVar->vt);
if (VariantBlobToString(
(VARENUM) pVar->vt,
pData + (dwArrayItemSize * dwIndex),
strItem,
bTranslate,
FALSE))
strValue = strItem;
return bRet;
}
BOOL CPropInfo::PrepArrayVar(VARIANT *pVar, DWORD dwSize)
{
BOOL bRet = FALSE;
ASSERT((m_vt & VT_ARRAY) != 0);
VariantClear(pVar);
if (dwSize > 0)
{
SAFEARRAYBOUND bound;
pVar->vt = m_vt;
if (pVar->vt == (VT_I8 | VT_ARRAY))
pVar->vt = VT_BSTR | VT_ARRAY;
bound.lLbound = 0;
bound.cElements = dwSize;
pVar->parray = SafeArrayCreate(pVar->vt & ~VT_ARRAY, 1, &bound);
bRet = pVar->parray != NULL;
}
else
{
pVar->vt = VT_NULL;
bRet = TRUE;
}
return bRet;
}
BOOL CPropInfo::StringToArrayItem(LPCTSTR szItem, VARIANT *pVar, DWORD dwIndex,
BOOL bTranslate)
{
//ASSERT(m_vt & VT_ARRAY);
ASSERT(pVar->vt & VT_ARRAY);
ASSERT(dwIndex < pVar->parray->rgsabound[0].cElements);
BOOL bRet = TRUE;
LPBYTE pData = (LPBYTE) pVar->parray->pvData;
DWORD dwArrayItemSize = GetArrayItemSize((VARENUM) pVar->vt);
bRet =
StringToVariantBlob(szItem, pData + (dwArrayItemSize * dwIndex),
bTranslate);
return bRet;
}
int CPropInfo::GetArrayItemSize(VARENUM vt)
{
switch(vt & ~VT_ARRAY)
{
case VT_UI1:
case VT_I1:
return 1;
case VT_BOOL:
case VT_I2:
return 2;
case VT_I4:
return 4;
case VT_I8:
return 8;
case VT_UNKNOWN:
case VT_BSTR:
return sizeof(BSTR*);
case VT_R4:
return sizeof(float);
case VT_R8:
return sizeof(double);
default:
// This shouldn't happen! If it does, add another case statement.
ASSERT(FALSE);
return 0;
}
}
BOOL CPropInfo::VariantToString(VARIANT *pVar, CString &strValue,
BOOL bTranslate, BOOL bQuoteStrings)
{
BOOL bRet = TRUE;
if (pVar->vt != VT_NULL)
{
if (pVar->vt & VT_ARRAY)
{
DWORD dwArrayItemSize = GetArrayItemSize((VARENUM) pVar->vt);
strValue.Empty();
LPBYTE pData = (LPBYTE) pVar->parray->pvData;
CString strItem;
for (int i = 0; i < pVar->parray->rgsabound[0].cElements;
i++, pData += dwArrayItemSize)
{
VariantBlobToString((VARENUM) pVar->vt, pData, strItem,
bTranslate, bQuoteStrings);
if (i != 0)
strValue += _T(", ");
strValue += strItem;
}
}
else
{
LPVOID pData = &V_BSTR(pVar);
VariantBlobToString((VARENUM) pVar->vt, pData, strValue,
bTranslate, bQuoteStrings);
}
}
else
strValue.LoadString(IDS_NULL);
return bRet;
}
// Use this to get __ExtendedStatus.
IWbemClassObject *GetWMIErrorObject()
{
IWbemClassObject *pObj = NULL;
IErrorInfo *pInfo = NULL;
if (SUCCEEDED(GetErrorInfo(0, &pInfo)) && pInfo != NULL)
{
pInfo->QueryInterface(IID_IWbemClassObject, (LPVOID*) &pObj);
pInfo->Release();
}
return pObj;
}
// Wbemcomn.dll prototypes.
typedef HRESULT (IWbemClassObject::*FPGET_PROPERTY_HANDLE_EX)(LPCWSTR, CIMTYPE*, long*);
typedef LPVOID (IWbemClassObject::*FPGET_ARRAY_BY_HANDLE)(long);
void CObjInfo::DoDebugStuff()
{
// I tried doing directly (from GetProcAddress into memember vars) but
// I couldn't come up with a conversion the compiler would let me do.
// So, do it the hardway.
HINSTANCE hWbemComn = GetModuleHandle(_T("wbemcomn.dll"));
FARPROC fpGetPropertyHandleEx =
GetProcAddress(
hWbemComn,
"?GetPropertyHandleEx@CWbemObject@@QAEJPBGPAJ1@Z");
FARPROC fpGetArrayByHandle =
GetProcAddress(
hWbemComn,
"?GetArrayByHandle@CWbemObject@@QAEPAVCUntypedArray@@J@Z");
FPGET_PROPERTY_HANDLE_EX
m_fpGetPropertyHandleEx;
FPGET_ARRAY_BY_HANDLE
m_fpGetArrayByHandle;
memcpy(
&m_fpGetPropertyHandleEx,
&fpGetPropertyHandleEx,
sizeof(fpGetPropertyHandleEx));
memcpy(
&m_fpGetArrayByHandle,
&fpGetArrayByHandle,
sizeof(fpGetArrayByHandle));
SAFEARRAY *pArr = NULL;
if (SUCCEEDED(m_pObj->GetNames(NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL, &pArr)))
{
BSTR *pNames = (BSTR*) pArr->pvData;
int nItems = pArr->rgsabound[0].cElements;
for (int i = 0; i < nItems; i++)
{
CIMTYPE type;
long handle;
if (SUCCEEDED(
(m_pObj->*m_fpGetPropertyHandleEx)(
pNames[i],
&type,
&handle)))
{
LPVOID pData = (m_pObj->*m_fpGetArrayByHandle)(handle);
int x;
x = 3;
HRESULT hr;
_variant_t vValue;
hr =
m_pObj->Get(
pNames[i],
0,
&vValue,
&type,
NULL);
BSTR *pStrings = NULL;
if (vValue.vt == (VT_BSTR | VT_ARRAY))
pStrings = (BSTR*) vValue.parray->pvData;
hr =
m_pObj->Put(
pNames[i],
0,
&vValue,
0);
}
}
SafeArrayDestroy(pArr);
}
}