able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/hmonitor/snapin/wbemclassobject.cpp

1767 lines
37 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// WbemClassObject.cpp: implementation of the CWbemClassObject class.
//
// Copyright (c) 2000 Microsoft Corporation
//
// 03/26/00 v-marfin 60751 : In function CreateEnumerator(), if LogicalDisk, assume that error 0x80041001 is due to the
// fact the user does not have logicaldisk perfmon turned on.
// Advise them to run "DiskPerf -YV" and reboot.
// 03/30/00 v-marfin 62531 : Allow an empty array as a means of removing a property of type array.
//
#include "stdafx.h"
#include "SnapIn.h"
#include "WbemClassObject.h"
#include "WbemEventListener.h"
#include <objbase.h>
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
IMPLEMENT_DYNCREATE(CWbemClassObject,CObject)
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CWbemClassObject::CWbemClassObject()
{
m_pIEnumerator = NULL;
m_pIWbemClassObject = NULL;
}
CWbemClassObject::~CWbemClassObject()
{
Destroy();
}
//////////////////////////////////////////////////////////////////////
// Create/Destroy
//////////////////////////////////////////////////////////////////////
HRESULT CWbemClassObject::Create(const CString& sMachineName)
{
TRACEX(_T("CWbemClassObject::Create\n"));
TRACEARGs(sMachineName);
m_sMachineName = sMachineName;
return S_OK;
}
HRESULT CWbemClassObject::Create(IWbemClassObject* pObject)
{
TRACEX(_T("CWbemClassObject::Create\n"));
TRACEARGn(pObject);
ASSERT(pObject);
if( pObject )
{
m_pIWbemClassObject = pObject;
return S_OK;
}
else
{
return E_FAIL;
}
}
void CWbemClassObject::Destroy()
{
TRACEX(_T("CWbemClassObject::Destroy\n"));
if( m_pIEnumerator )
{
m_pIEnumerator->Release();
m_pIEnumerator = NULL;
}
if( m_pIWbemClassObject )
{
m_pIWbemClassObject->Release();
m_pIWbemClassObject = NULL;
}
m_sMachineName.Empty();
m_sNamespace.Empty();
}
//////////////////////////////////////////////////////////////////////
// Property Operations
//////////////////////////////////////////////////////////////////////
// v-marfin
//***********************************************************************************
// GetRawProperty
//
// This function retreives the raw property of the object. No conversions take
// place on it, no formatting, nothing. The user is responsible for determining
// the format and performing any conversions etc.
//***********************************************************************************
HRESULT CWbemClassObject::GetRawProperty(const CString& sProperty, VARIANT& vPropValue)
{
TRACEX(_T("CWbemClassObject::GetRawProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::GetRawProperty failed.\n"));
::SysFreeString(bsProperty);
return hr;
}
::SysFreeString(bsProperty);
return hr;
}
//***********************************************************************************
// SetRawProperty
//
// This function sets the raw property of the object. No conversions take
// place on it, no formatting, nothing. The user is responsible for ensuring
// that the data is in its proper format etc.
//***********************************************************************************
HRESULT CWbemClassObject::SetRawProperty(const CString& sProperty, VARIANT& vPropValue)
{
TRACEX(_T("CWbemClassObject::SetRawProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, &vPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::SetRawProperty failed.\n"));
TRACEARGn(hr);
::SysFreeString(bsProperty);
return hr;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::GetPropertyNames(CStringArray& saNames)
{
TRACEX(_T("CWbemClassObject::GetPropertyNames\n"));
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
TRACE(_T("FAILED : m_pIWbemClassObject is NULL\n"));
return E_FAIL;
}
HRESULT hr = S_OK;
SAFEARRAY* psa = NULL;
if( ! CHECKHRESULT(hr = m_pIWbemClassObject->GetNames(NULL,WBEM_FLAG_ALWAYS|WBEM_FLAG_NONSYSTEM_ONLY,NULL,&psa)) )
{
return hr;
}
COleSafeArray osa(*psa,VT_BSTR);
long lLower = 0L;
long lUpper = -1L;
osa.GetLBound(1L,&lLower);
osa.GetUBound(1L,&lUpper);
for( long i = lLower; i <= lUpper; i++ )
{
BSTR bsPropertyName;
osa.GetElement(&i,&bsPropertyName);
saNames.Add(CString(bsPropertyName));
}
return hr;
}
HRESULT CWbemClassObject::GetPropertyType(const CString& sPropertyName, CString& sType)
{
TRACEX(_T("CWbemClassObject::GetPropertyType\n"));
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
TRACE(_T("FAILED : m_pIWbemClassObject is NULL\n"));
return E_FAIL;
}
HRESULT hr = S_OK;
CIMTYPE type;
if( ! CHECKHRESULT( hr = GetPropertyType(sPropertyName,type) ) )
{
return hr;
}
sType.Empty();
if( type & CIM_FLAG_ARRAY )
{
sType.LoadString(IDS_STRING_ARRAY_OF);
type &= ~CIM_FLAG_ARRAY;
}
CString sResString;
switch( type )
{
case CIM_ILLEGAL:
{
sResString.LoadString(IDS_STRING_CIM_ILLEGAL);
sType += sResString;
}
break;
case CIM_EMPTY:
{
sResString.LoadString(IDS_STRING_CIM_EMPTY);
sType += sResString;
}
break;
case CIM_SINT8:
case CIM_SINT16:
case CIM_SINT32:
case CIM_SINT64:
{
sResString.LoadString(IDS_STRING_CIM_SINT);
sType += sResString;
}
break;
case CIM_UINT8:
case CIM_UINT16:
case CIM_UINT32:
case CIM_UINT64:
{
sResString.LoadString(IDS_STRING_CIM_UINT);
sType += sResString;
}
break;
case CIM_REAL32:
case CIM_REAL64:
{
sResString.LoadString(IDS_STRING_CIM_REAL);
sType += sResString;
}
break;
case CIM_BOOLEAN:
{
sResString.LoadString(IDS_STRING_CIM_BOOLEAN);
sType += sResString;
}
break;
case CIM_STRING:
{
sResString.LoadString(IDS_STRING_CIM_STRING);
sType += sResString;
}
break;
case CIM_DATETIME:
{
sResString.LoadString(IDS_STRING_CIM_DATETIME);
sType += sResString;
}
break;
case CIM_REFERENCE:
{
sResString.LoadString(IDS_STRING_CIM_REFERENCE);
sType += sResString;
}
break;
case CIM_CHAR16:
{
sResString.LoadString(IDS_STRING_CIM_CHAR16);
sType += sResString;
}
break;
case CIM_OBJECT:
{
sResString.LoadString(IDS_STRING_CIM_OBJECT);
sType += sResString;
}
break;
default:
{
hr = E_FAIL;
ASSERT(FALSE);
sType.Empty();
}
}
return hr;
}
HRESULT CWbemClassObject::GetPropertyType(const CString& sPropertyName, CIMTYPE& Type)
{
TRACEX(_T("CWbemClassObject::GetPropertyType\n"));
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
TRACE(_T("FAILED : m_pIWbemClassObject is NULL\n"));
return E_FAIL;
}
HRESULT hr = S_OK;
BSTR bsProperty = sPropertyName.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
hr = m_pIWbemClassObject->Get(bsProperty, 0L, NULL, &Type, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( TYPE ) failed.\n"));
::SysFreeString(bsProperty);
return hr;
}
::SysFreeString(bsProperty);
return hr;
}
HRESULT CWbemClassObject::SaveAllProperties()
{
TRACEX(_T("CWbemClassObject::SaveAllProperties\n"));
ASSERT(!m_sMachineName.IsEmpty());
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
TRACE(_T("FAILED : m_pIWbemClassObject is NULL\n"));
return E_FAIL;
}
// update this instance
hr = pServices->PutInstance(m_pIWbemClassObject,WBEM_FLAG_CREATE_OR_UPDATE,NULL,NULL);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemServices::PutInstance failed\n"));
return hr;
}
return hr;
}
bool CWbemClassObject::GetPropertyValueFromString(const CString& sWMIString, const CString& sPropName, CString& sProperty)
{
TRACEX(_T("CWbemClassObject::GetPropertyValueFromString\n"));
TRACEARGs(sWMIString);
TRACEARGs(sPropName);
int iStart = -1;
if( (iStart = sWMIString.Find(sPropName)) != -1 )
{
sProperty = sWMIString.Right(sWMIString.GetLength() - iStart);
int iEnd = sProperty.Find(_T(","));
if( iEnd == -1 )
{
iEnd = sProperty.Find(_T(" AND "));
if( iEnd == -1 )
{
iEnd = sProperty.GetLength();
}
}
sProperty = sProperty.Left(iEnd);
iStart = sProperty.Find(_T("=")) + 1;
sProperty = sProperty.Right(sProperty.GetLength()-iStart);
sProperty.TrimLeft(_T("\""));
sProperty.TrimRight(_T("\""));
return true;
}
sProperty.Empty();
return false; // did not find the property name in the path
}
//////////////////////////////////////////////////////////////////////
// WBEM Operations
//////////////////////////////////////////////////////////////////////
HRESULT CWbemClassObject::GetObject(const CString& sObjectPath)
{
TRACEX(_T("CWbemClassObject::GetObject\n"));
TRACEARGs(sObjectPath);
// do not call me if you have not called Destroy first
ASSERT(m_pIWbemClassObject == NULL);
ASSERT(sObjectPath.GetLength());
if( sObjectPath.IsEmpty() )
{
TRACE(_T("FAILED : sObjectPath is NULL. Failed.\n"));
return E_FAIL;
}
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
VERIFY(pServices);
// get the object's signature
BSTR bsPath = sObjectPath.AllocSysString();
hr = pServices->GetObject(bsPath, 0, NULL, &m_pIWbemClassObject, NULL);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemServices::GetObject failed.\n"));
::SysFreeString(bsPath);
return hr;
}
::SysFreeString(bsPath);
return hr;
}
HRESULT CWbemClassObject::GetObjectText(CString& sText)
{
TRACEX(_T("CWbemClassObject::GetObjectText\n"));
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
HRESULT hr = S_OK;
BSTR bsText = NULL;
if( ! CHECKHRESULT(hr = m_pIWbemClassObject->GetObjectText(0L,&bsText)) )
{
return hr;
}
sText = bsText;
::SysFreeString(bsText);
return hr;
}
HRESULT CWbemClassObject::ExecQuery(BSTR bsQueryString)
{
TRACEX(_T("CWbemClassObject::ExecQuery\n"));
TRACEARGs(bsQueryString);
ASSERT(bsQueryString);
if( bsQueryString == NULL )
{
TRACE(_T("FAILED : bsQueryString is NULL. CWbemClassObject::ExecQuery Failed.\n"));
return E_FAIL;
}
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
BSTR bsLanguage = SysAllocString(_T("WQL"));
m_pIEnumerator = NULL;
// Issue Query
hr = pServices->ExecQuery(bsLanguage,bsQueryString,WBEM_FLAG_BIDIRECTIONAL,0,&m_pIEnumerator);
SysFreeString(bsLanguage);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemServices::ExecQuery failed.\n"));
return hr;
}
ASSERT(m_pIEnumerator);
SetBlanket(m_pIEnumerator);
return hr;
}
HRESULT CWbemClassObject::ExecQueryAsync(BSTR bsQueryString, CWbemEventListener* pListener)
{
TRACEX(_T("CWbemClassObject::ExecQueryAsync\n"));
TRACEARGs(bsQueryString);
ASSERT(bsQueryString);
if( bsQueryString == NULL )
{
TRACE(_T("FAILED : bsQueryString is NULL. CWbemClassObject::ExecQuery Failed.\n"));
return E_FAIL;
}
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
BSTR bsLanguage = SysAllocString(_T("WQL"));
m_pIEnumerator = NULL;
// Issue Query
hr = pServices->ExecQueryAsync(bsLanguage,bsQueryString,WBEM_FLAG_BIDIRECTIONAL,0,pListener->GetSink());
SysFreeString(bsLanguage);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemServices::ExecQuery failed.\n"));
return hr;
}
return hr;
}
HRESULT CWbemClassObject::CreateEnumerator(BSTR bsClassName)
{
TRACEX(_T("CWbemClassObject::CreateEnumerator\n"));
ASSERT(bsClassName);
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
DisplayErrorMsgBox(hr);
return hr;
}
ASSERT(pServices);
hr = pServices->CreateInstanceEnum(bsClassName,WBEM_FLAG_SHALLOW|
WBEM_FLAG_BIDIRECTIONAL, NULL, &m_pIEnumerator);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
// v-marfin 60751 : If LogicalDisk, assume that error 0x80041001 is due to the
// fact the user does not have logicaldisk perfmon turned on.
// Advise them to run "DiskPerf -YV" and reboot.
if ((hr == 0x80041001) && (CString(bsClassName).CompareNoCase(_T("LogicalDisk")) == 0))
{
AfxMessageBox(IDS_WARNING_DISKPERF);
return hr;
}
DisplayErrorMsgBox(hr);
return hr;
}
SetBlanket(m_pIEnumerator);
return hr;
}
HRESULT CWbemClassObject::CreateClassEnumerator(BSTR bsClassName)
{
TRACEX(_T("CWbemClassObject::CreateClassEnumerator\n"));
TRACEARGs(bsClassName);
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
DisplayErrorMsgBox(hr);
return hr;
}
ASSERT(pServices);
hr = pServices->CreateClassEnum(bsClassName,WBEM_FLAG_DEEP|
WBEM_FLAG_RETURN_IMMEDIATELY|
WBEM_FLAG_FORWARD_ONLY, NULL, &m_pIEnumerator);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
DisplayErrorMsgBox(hr);
return hr;
}
SetBlanket(m_pIEnumerator);
return hr;
}
HRESULT CWbemClassObject::CreateAsyncEnumerator(BSTR bsClassName, CWbemEventListener* pListener)
{
TRACEX(_T("CWbemClassObject::CreateEnumerator\n"));
ASSERT(bsClassName);
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
hr = pServices->CreateInstanceEnumAsync(bsClassName,WBEM_FLAG_SHALLOW|
WBEM_FLAG_RETURN_IMMEDIATELY|
WBEM_FLAG_FORWARD_ONLY, NULL, pListener->GetSink() );
pServices->Release();
if( !CHECKHRESULT(hr) )
{
return hr;
}
return hr;
}
HRESULT CWbemClassObject::GetNextObject(ULONG& uReturned)
{
ASSERT(m_pIEnumerator);
if( m_pIEnumerator == NULL )
{
return E_FAIL;
}
if( m_pIWbemClassObject )
{
m_pIWbemClassObject->Release();
m_pIWbemClassObject = NULL;
}
HRESULT hr = m_pIEnumerator->Next(WBEM_INFINITE,1,&m_pIWbemClassObject,&uReturned);
if( FAILED(hr) )
{
TRACEARGn(hr);
TRACE(_T("WARNING : IEnumWbemClassObject::Next failed to find another instance\n"));
return hr;
}
return hr;
}
HRESULT CWbemClassObject::Reset()
{
TRACEX(_T("CWbemClassObject::Reset\n"));
ASSERT(m_pIEnumerator);
if( m_pIEnumerator == NULL )
{
return E_FAIL;
}
HRESULT hr = m_pIEnumerator->Reset();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IEnumWbemClassObject::Reset failed.\n"));
return hr;
}
return hr;
}
HRESULT CWbemClassObject::CreateInstance(BSTR bsClassName)
{
TRACEX(_T("CWbemClassObject::CreateInstance\n"));
TRACEARGs(bsClassName);
// do not call me if you have not called Destroy first
ASSERT(m_pIWbemClassObject == NULL);
ASSERT(bsClassName);
if( bsClassName == NULL )
{
TRACE(_T("FAILED : bsClassName is NULL. Failed.\n"));
return E_FAIL;
}
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
// get the object's signature
IWbemClassObject* pClassObject = NULL;
hr = pServices->GetObject(bsClassName, 0, NULL, &pClassObject, NULL);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemServices::GetObject failed.\n"));
return hr;
}
// create an instance of the class based on the signature
ASSERT(pClassObject);
hr = pClassObject->SpawnInstance(0,&m_pIWbemClassObject);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::SpawnInstance failed.\n"));
pClassObject->Release();
return hr;
}
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
TRACE(_T("FAILED : An unexpected error occurred with IWbemClassObject::SpawnInstance. Failed\n"));
return E_FAIL;
}
pClassObject->Release();
return S_OK;
}
HRESULT CWbemClassObject::DeleteInstance(const CString& sClassObjectPath)
{
TRACEX(_T("CWbemClassObject::DeleteInstance"));
TRACEARGs(sClassObjectPath);
if( sClassObjectPath.IsEmpty() )
{
TRACE(_T("FAILED : bsClassInstanceName is NULL. Failed.\n"));
return E_FAIL;
}
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
BSTR bsClassInstanceName = sClassObjectPath.AllocSysString();
hr = pServices->DeleteInstance(bsClassInstanceName,0L,NULL,NULL);
::SysFreeString(bsClassInstanceName);
pServices->Release();
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemServices::DeleteInstance failed.\n"));
return hr;
}
return hr;
}
HRESULT CWbemClassObject::GetMethod(const CString& sMethodName, CWbemClassObject& MethodInput)
{
TRACEX(_T("CWbemClassObject::GetMethod\n"));
TRACEARGs(sMethodName);
if( m_pIWbemClassObject == NULL )
{
ASSERT(FALSE);
return E_FAIL;
}
IWbemClassObject* pInClass = NULL;
IWbemClassObject* pOutClass = NULL;
BSTR bsMethodName = sMethodName.AllocSysString();
HRESULT hr = m_pIWbemClassObject->GetMethod(bsMethodName, 0, &pInClass, &pOutClass);
if( ! CHECKHRESULT(hr) || pInClass == NULL )
{
::SysFreeString(bsMethodName);
return hr;
}
ASSERT(pInClass);
IWbemClassObject* pInInst = NULL;
if( pInClass )
{
hr = pInClass->SpawnInstance(0, &pInInst);
pInClass->Release();
if( ! CHECKHRESULT(hr) || pInInst == NULL )
{
::SysFreeString(bsMethodName);
return hr;
}
}
if( pOutClass )
{
pOutClass->Release();
}
ASSERT(pInInst);
MethodInput.Create(pInInst);
::SysFreeString(bsMethodName);
return S_OK;
}
HRESULT CWbemClassObject::ExecuteMethod(const CString& sMethodName, const CString& sArgumentName, const CString& sArgumentValue, int& iReturnValue)
{
TRACEX(_T("CWbemClassObject::ExecuteMethod\n"));
TRACEARGs(sMethodName);
TRACEARGs(sArgumentName);
TRACEARGs(sArgumentValue);
if( sMethodName.IsEmpty() )
{
return E_FAIL;
}
if( sArgumentName.IsEmpty() )
{
return E_FAIL;
}
if( sArgumentValue.IsEmpty() )
{
return E_FAIL;
}
if( m_pIWbemClassObject == NULL )
{
ASSERT(FALSE);
return E_FAIL;
}
CWbemClassObject InInstance;
CWbemClassObject OutInstance;
HRESULT hr = GetMethod(sMethodName,InInstance);
if( ! CHECKHRESULT(hr) )
{
return hr;
}
InInstance.SetProperty(sArgumentName,sArgumentValue);
hr = ExecuteMethod(sMethodName,InInstance,OutInstance);
return hr;
}
HRESULT CWbemClassObject::ExecuteMethod(const CString& sMethodName, CWbemClassObject& InInstance, CWbemClassObject& OutInstance)
{
TRACEX(_T("CWbemClassObject::ExecuteMethod\n"));
TRACEARGs(sMethodName);
IWbemServices* pServices = NULL;
HRESULT hr = S_OK;
if( ! CHECKHRESULT(hr = Connect(pServices)) )
{
return hr;
}
ASSERT(pServices);
// Call the method
IWbemClassObject* pOutInst = NULL;
IWbemClassObject* pInInst = InInstance.GetClassObject();
CString sPath;
GetProperty(_T("__PATH"),sPath);
BSTR bsPath = sPath.AllocSysString();
BSTR bsMethodName = sMethodName.AllocSysString();
hr = pServices->ExecMethod(bsPath, bsMethodName, 0, NULL, pInInst, &pOutInst, NULL);
if( pInInst )
{
pInInst->Release();
}
if( ! CHECKHRESULT(hr) )
{
::SysFreeString(bsMethodName);
::SysFreeString(bsPath);
return hr;
}
if( pOutInst )
{
OutInstance.Create(pOutInst);
}
::SysFreeString(bsMethodName);
::SysFreeString(bsPath);
return S_OK;
}
HRESULT CWbemClassObject::GetLocaleStringProperty(const CString& sProperty, CString& sPropertyValue)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
HRESULT hr = GetProperty(sProperty,sPropertyValue);
if( ! CHECKHRESULT(hr) )
{
return hr;
}
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, CString& sPropertyValue)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( BSTR ) failed.\n"));
::SysFreeString(bsProperty);
sPropertyValue.Empty();
return hr;
}
if( V_VT(&vPropValue) != VT_NULL )
{
sPropertyValue = V_BSTR(&vPropValue);
}
else
{
sPropertyValue.Empty();
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, int& iPropertyValue)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( int ) failed.\n"));
iPropertyValue = 0;
::SysFreeString(bsProperty);
return hr;
}
iPropertyValue = V_I4(&vPropValue);
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, bool& bPropertyValue)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( int ) failed.\n"));
bPropertyValue = false;
::SysFreeString(bsProperty);
return hr;
}
bPropertyValue = ((V_BOOL(&vPropValue)==VARIANT_TRUE) ? true : false);
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, float& fPropertyValue)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( float ) failed.\n"));
fPropertyValue = 0;
::SysFreeString(bsProperty);
return hr;
}
fPropertyValue = V_R4(&vPropValue);
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, COleSafeArray& ArrayPropertyValue)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( SAFEARRAY ) failed.\n"));
::SysFreeString(bsProperty);
return hr;
}
if( V_VT(&vPropValue) != VT_NULL )
{
ArrayPropertyValue.Attach(vPropValue);
}
else
{
hr = S_FALSE;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, CTime& time, bool bConvertToLocalTime /*= true*/)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
CString sPropertyValue;
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
HRESULT hr = m_pIWbemClassObject->Get(bsProperty, 0L, &vPropValue, NULL, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Get( BSTR ) failed.\n"));
::SysFreeString(bsProperty);
sPropertyValue.Empty();
return hr;
}
if( V_VT(&vPropValue) != VT_NULL )
{
sPropertyValue = V_BSTR(&vPropValue);
}
else
{
time = CTime();
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_FALSE;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
bool bIncomplete = false;
if( sPropertyValue.Find(_T("*")) != -1 )
{
sPropertyValue.Replace(_T('*'),_T('0'));
bIncomplete = true;
}
// parse the DTime format string
SYSTEMTIME st;
int iBias = -1;
int iYear;
int iMonth;
int iDay;
int iHour;
int iMinute;
int iSecond;
int iMSeconds;
_stscanf(sPropertyValue,IDS_STRING_DATETIME_FORMAT,&iYear,
&iMonth,
&iDay,
&iHour,
&iMinute,
&iSecond,
&iMSeconds,
&iBias);
st.wYear = (WORD)iYear;
st.wMonth = (WORD)iMonth;
st.wDay = (WORD)iDay;
st.wHour = (WORD)iHour;
st.wMinute = (WORD)iMinute;
st.wSecond = (WORD)iSecond;
st.wMilliseconds = (WORD)iMSeconds;
if( bConvertToLocalTime )
{
if( iBias != 0 )
{
CTime time = st;
CTime utc;
if( iBias < 0 )
{
iBias = -iBias;
}
CTimeSpan ts(0,0,iBias,0);
utc = time + ts;
utc.GetAsSystemTime(st);
st.wDayOfWeek = 0;
}
// adjust to the local time zone
TIME_ZONE_INFORMATION tzi;
SYSTEMTIME stLocal;
GetTimeZoneInformation(&tzi);
SystemTimeToTzSpecificLocalTime(&tzi,&st,&stLocal);
time = stLocal;
}
else
{
if( bIncomplete )
{
CTime current = CTime::GetCurrentTime();
st.wYear = (WORD)current.GetYear();
st.wMonth = (WORD)current.GetMonth();
st.wDay = (WORD)current.GetDay();
}
time = st;
}
sPropertyValue.Empty();
return hr;
}
HRESULT CWbemClassObject::GetProperty(const CString& sProperty, CStringArray& saPropertyValues)
{
TRACEX(_T("CWbemClassObject::GetProperty\n"));
TRACEARGs(sProperty);
saPropertyValues.RemoveAll();
COleSafeArray StringArray;
HRESULT hr = GetProperty(sProperty,StringArray);
if( hr == S_FALSE )
{
return hr;
}
// process the strings in the SAFEARRAY
long lLower = 0L;
long lUpper = -1L;
CString sPropertyValue;
StringArray.GetLBound(1L,&lLower);
StringArray.GetUBound(1L,&lUpper);
for( long i = lLower; i <= lUpper; i++ )
{
BSTR bsPropertyValue = NULL;
StringArray.GetElement(&i,&bsPropertyValue);
sPropertyValue = bsPropertyValue;
saPropertyValues.Add(sPropertyValue);
}
return hr;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, CString sPropertyValue)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
V_VT(&vPropValue) = VT_BSTR;
V_BSTR(&vPropValue) = sPropertyValue.AllocSysString();
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, &vPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Put( string ) failed.\n"));
::SysFreeString(bsProperty);
return hr;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, int iPropertyValue)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
TRACEARGn(iPropertyValue);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
V_VT(&vPropValue) = VT_I4;
V_I4(&vPropValue) = iPropertyValue;
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, &vPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Put( int ) failed.\n"));
TRACEARGn(hr);
::SysFreeString(bsProperty);
return hr;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, bool bPropertyValue)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
TRACEARGn(bPropertyValue);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
V_VT(&vPropValue) = VT_BOOL;
V_BOOL(&vPropValue) = bPropertyValue ? VARIANT_TRUE : VARIANT_FALSE;
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, &vPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Put( int ) failed.\n"));
TRACEARGn(hr);
::SysFreeString(bsProperty);
return hr;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, float fPropertyValue)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
TRACEARGn(fPropertyValue);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
VARIANT vPropValue;
VariantInit(&vPropValue);
V_VT(&vPropValue) = VT_R4;
V_R4(&vPropValue) = fPropertyValue;
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, &vPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Put( float ) failed."));
::SysFreeString(bsProperty);
return hr;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, CTime time, bool bConvertToGMTTime /*= true*/)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
CString sPropertyValue;
if( bConvertToGMTTime )
{
// format the time to comply with WMI DTime string type
tm tmGmt = *(time.GetGmtTm());
sPropertyValue.Format(IDS_STRING_DATETIME_FORMAT2,tmGmt.tm_year,
tmGmt.tm_mon,
tmGmt.tm_mday,
tmGmt.tm_hour,
tmGmt.tm_min,
tmGmt.tm_sec,
0,
_T("+000"));
}
else
{
sPropertyValue.Format(IDS_STRING_DATETIME_FORMAT2,time.GetYear(),
time.GetMonth(),
time.GetDay(),
time.GetHour(),
time.GetMinute(),
time.GetSecond(),
0,
_T("+000"));
}
VARIANT vPropValue;
VariantInit(&vPropValue);
V_VT(&vPropValue) = VT_BSTR;
V_BSTR(&vPropValue) = sPropertyValue.AllocSysString();
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, &vPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Put( string ) failed.\n"));
::SysFreeString(bsProperty);
return hr;
}
VariantClear(&vPropValue);
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, COleSafeArray& ArrayPropertyValue)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
ASSERT(m_pIWbemClassObject);
if( m_pIWbemClassObject == NULL )
{
return E_FAIL;
}
BSTR bsProperty = sProperty.AllocSysString();
ASSERT(bsProperty);
if( bsProperty == NULL )
{
return E_FAIL;
}
LPVARIANT lpvPropValue = LPVARIANT(ArrayPropertyValue);
HRESULT hr = m_pIWbemClassObject->Put(bsProperty, 0L, lpvPropValue, NULL);
if( !CHECKHRESULT(hr) )
{
TRACE(_T("FAILED : IWbemClassObject::Put( SAFEARRAY ) failed.\n"));
TRACEARGn(hr);
::SysFreeString(bsProperty);
return hr;
}
::SysFreeString(bsProperty);
return S_OK;
}
HRESULT CWbemClassObject::SetProperty(const CString& sProperty, const CStringArray& saPropertyValues)
{
TRACEX(_T("CWbemClassObject::SetProperty\n"));
TRACEARGs(sProperty);
//----------------------------------------------------------------------------------------
// v-marfin 62531b : Allow an empty array as a means of removing a property of type array
if( saPropertyValues.GetSize() == 0 )
{
HRESULT hr=0;
VARIANT vNULL;
VariantInit(&vNULL);
hr = VariantChangeType(&vNULL,&vNULL,0,VT_NULL);
hr = SetRawProperty(sProperty,vNULL);
return hr;
}
//----------------------------------------------------------------------------------------
COleSafeArray StringArray;
StringArray.CreateOneDim(VT_BSTR,(int)saPropertyValues.GetSize());
// process the strings in the SAFEARRAY
CString sPropertyValue;
for( long i = 0; i < saPropertyValues.GetSize(); i++ )
{
BSTR bsPropertyValue = saPropertyValues[i].AllocSysString();
StringArray.PutElement(&i,bsPropertyValue);
::SysFreeString(bsPropertyValue);
}
HRESULT hr = SetProperty(sProperty,StringArray);
return hr;
}
inline HRESULT CWbemClassObject::Connect(IWbemServices*& pServices)
{
TRACEX(_T("CWbemClassObject::Connect\n"));
TRACEARGn(pServices);
HRESULT hr = S_OK;
if( m_sNamespace.IsEmpty() ) // connect to a system
{
BOOL bAvail;
if( (hr = CnxGetConnection(m_sMachineName,pServices,bAvail)) != S_OK )
{
TRACE(_T("FAILED : Could not retrieve a connection for the machine. Failed.\n"));
return hr;
}
if( ! bAvail )
return E_FAIL;
}
else // connect to a specific namespace
{
if( (hr = CnxConnectToNamespace(m_sNamespace,pServices)) != S_OK )
{
TRACE(_T("FAILED : Could not retrieve a connection for the machine. Failed.\n"));
return hr;
}
}
SetBlanket(pServices);
return hr;
}
inline HRESULT CWbemClassObject::SetBlanket(LPUNKNOWN pIUnk)
{
return CoSetProxyBlanket( pIUnk,
RPC_C_AUTHN_WINNT, // NTLM authentication service
RPC_C_AUTHZ_NONE, // default authorization service...
NULL, // no mutual authentication
RPC_C_AUTHN_LEVEL_CONNECT, // authentication level
RPC_C_IMP_LEVEL_IMPERSONATE, // impersonation level
NULL, // use current token
EOAC_NONE ); // no special capabilities
}
inline void CWbemClassObject::DisplayErrorMsgBox(HRESULT hr)
{
// construct the path and load wbemcomn.dll for error messages
TCHAR szWinDir[_MAX_PATH];
GetWindowsDirectory(szWinDir,_MAX_PATH);
CString sModulePath;
sModulePath.Format(_T("%s\\SYSTEM32\\WBEM\\WBEMCOMN.DLL"),szWinDir);
HMODULE hModule = LoadLibrary(sModulePath);
TCHAR szMsg[_MAX_PATH*4];
DWORD dwCount = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_FROM_HMODULE|FORMAT_MESSAGE_IGNORE_INSERTS,
hModule,
hr,
0,
szMsg,
_MAX_PATH*4*sizeof(TCHAR),
NULL
);
CString sMsg;
CString sNamespace = GetNamespace();
if( sNamespace.IsEmpty() )
{
sNamespace.Format(IDS_STRING_HEALTHMON_ROOT,GetMachineName());
}
if( dwCount )
{
sMsg.Format(IDS_STRING_WMI_ERROR,sNamespace,hr,szMsg);
}
else
{
CString sUnknown;
sUnknown.LoadString(IDS_STRING_UNKNOWN);
sMsg.Format(IDS_STRING_WMI_ERROR,sNamespace,hr,sUnknown);
}
AfxMessageBox(sMsg);
FreeLibrary(hModule);
}
Reference in a new issue Copy permalink