1804 lines
47 KiB
C++
1804 lines
47 KiB
C++
//***************************************************************************
|
|
//
|
|
// Copyright (c) 1998-2000 Microsoft Corporation.
|
|
//
|
|
// File: cwbemdsp.cpp
|
|
//
|
|
// Description :
|
|
// Implementation of the IDispatch interface for Wbem Objects.
|
|
// This is mostly standard, except for the additional support for
|
|
// specifying the name of a Wbem class property/method directly as if it
|
|
// was a property/method of the actual CWbemObject class ("dot notation")
|
|
//
|
|
// Part of : WBEM automation interface layer
|
|
//
|
|
// History:
|
|
// corinaf 4/3/98 Created
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
|
|
const unsigned long CWbemDispID::s_wmiDispIdTypeMask = 0x03000000;
|
|
const unsigned long CWbemDispID::s_wmiDispIdTypeStatic = 0x00000000;
|
|
const unsigned long CWbemDispID::s_wmiDispIdTypeSchema = 0x01000000;
|
|
const unsigned long CWbemDispID::s_wmiDispIdSchemaTypeMask = 0x00800000;
|
|
const unsigned long CWbemDispID::s_wmiDispIdSchemaTypeProperty = 0x00800000;
|
|
const unsigned long CWbemDispID::s_wmiDispIdSchemaTypeMethod = 0x00000000;
|
|
const unsigned long CWbemDispID::s_wmiDispIdSchemaElementIDMask = 0x007FFFFF;
|
|
|
|
//Forward declaration
|
|
|
|
HRESULT assignArrayElementToVariant(SAFEARRAY *psa, VARTYPE vt, long inx, VARIANT *pvResult);
|
|
void assignVariantToArrayElement(SAFEARRAY *psa, VARTYPE vt, long inx, VARIANT *pvNewVal);
|
|
VARTYPE CimTypeToVtType(CIMTYPE lType);
|
|
HRESULT VariantChangeByValToByRef(VARIANT *dest, VARIANT *source, VARTYPE destType);
|
|
|
|
class CWbemSchemaIDCache
|
|
{
|
|
private:
|
|
typedef map<CComBSTR, CWbemDispID, BSTRless> DispIDNameMap;
|
|
|
|
unsigned long m_nextId;
|
|
DispIDNameMap m_cache;
|
|
CWbemDispatchMgr *m_pDispatchMgr;
|
|
|
|
bool FindPropertyName (BSTR bsName);
|
|
bool GetMethod (BSTR bstrMethodName, SAFEARRAY **ppsaInParams, SAFEARRAY **ppsaOutParams,
|
|
CComPtr<IWbemClassObject> & pInParams, CComPtr<IWbemClassObject> & pOutParams);
|
|
bool GetIdOfMethodParameter(BSTR bstrParamName, CComPtr<IWbemClassObject> & pParams, long *pId);
|
|
|
|
static bool FindMemberInArray(BSTR bstrName, SAFEARRAY *psaNames);
|
|
|
|
public:
|
|
CWbemSchemaIDCache (CWbemDispatchMgr *pDispMgr) :
|
|
m_nextId (0),
|
|
m_pDispatchMgr (pDispMgr) {}
|
|
virtual ~CWbemSchemaIDCache ();
|
|
|
|
HRESULT GetDispID (LPWSTR FAR* rgszNames, unsigned int cNames, DISPID FAR* rgdispid);
|
|
bool GetName (DISPID dispId, CComBSTR & bsName);
|
|
};
|
|
|
|
|
|
CWbemDispatchMgr::CWbemDispatchMgr(CSWbemServices *pWbemServices,
|
|
CSWbemObject *pSWbemObject) :
|
|
m_pWbemServices (pWbemServices),
|
|
m_pSWbemObject (pSWbemObject), // Backpointer to parent (not AddRef'd)
|
|
m_pWbemClass (NULL),
|
|
m_pTypeInfo (NULL),
|
|
m_pCTypeInfo (NULL),
|
|
m_hResult (S_OK)
|
|
{
|
|
m_pSchemaCache = new CWbemSchemaIDCache (this);
|
|
|
|
if (m_pWbemServices)
|
|
m_pWbemServices->AddRef ();
|
|
|
|
m_pWbemObject = pSWbemObject->GetIWbemClassObject ();
|
|
}
|
|
|
|
CWbemDispatchMgr::~CWbemDispatchMgr()
|
|
{
|
|
RELEASEANDNULL(m_pWbemServices)
|
|
RELEASEANDNULL(m_pWbemObject)
|
|
RELEASEANDNULL(m_pWbemClass)
|
|
RELEASEANDNULL(m_pTypeInfo)
|
|
RELEASEANDNULL(m_pCTypeInfo)
|
|
DELETEANDNULL(m_pSchemaCache)
|
|
}
|
|
|
|
void CWbemDispatchMgr::SetNewObject (IWbemClassObject *pNewObject)
|
|
{
|
|
if (m_pWbemObject && pNewObject)
|
|
{
|
|
m_pWbemObject->Release ();
|
|
m_pWbemObject = pNewObject;
|
|
m_pWbemObject->AddRef ();
|
|
|
|
CComVariant var;
|
|
|
|
if (SUCCEEDED(pNewObject->Get (WBEMS_SP_GENUS, 0, &var, NULL, NULL)) &&
|
|
(WBEM_GENUS_CLASS == var.lVal))
|
|
{
|
|
// This is a class, so update the class object too
|
|
if (m_pWbemClass)
|
|
m_pWbemClass->Release ();
|
|
|
|
m_pWbemClass = pNewObject;
|
|
m_pWbemClass->AddRef ();
|
|
}
|
|
|
|
// Clear out the caches
|
|
if (m_pSchemaCache)
|
|
{
|
|
delete m_pSchemaCache;
|
|
m_pSchemaCache = new CWbemSchemaIDCache (this);
|
|
}
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CWbemDispatchMgr::GetTypeInfoCount(unsigned int FAR* pctinfo)
|
|
{
|
|
*pctinfo = 1;
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CWbemDispatchMgr::GetTypeInfo(unsigned int itinfo,
|
|
LCID lcid,
|
|
ITypeInfo FAR* FAR* pptinfo)
|
|
{
|
|
HRESULT hr;
|
|
ITypeLib *pTypeLib = NULL;
|
|
|
|
//If Type Info is not cached already - load the library and
|
|
//get the Type Info, then cache it for further access
|
|
if (!m_pTypeInfo)
|
|
{
|
|
|
|
// Load Type Library.
|
|
hr = LoadRegTypeLib(LIBID_WbemScripting, 1, 0, lcid, &pTypeLib);
|
|
if (FAILED(hr))
|
|
{
|
|
// if it wasn't registered, try to load it from the path
|
|
// if this succeeds, it will have registered the type library for us
|
|
// for the next time.
|
|
hr = LoadTypeLib(OLESTR("wbemdisp.tlb"), &pTypeLib);
|
|
if(FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
// Get type information for interface of the object.
|
|
hr = pTypeLib->GetTypeInfoOfGuid(IID_ISWbemObjectEx, &m_pTypeInfo);
|
|
pTypeLib->Release();
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
}
|
|
|
|
//AddRef whenever returning another pointer to this
|
|
m_pTypeInfo->AddRef();
|
|
*pptinfo = m_pTypeInfo;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CWbemDispatchMgr::GetClassInfo(ITypeInfo FAR* FAR* pptinfo)
|
|
{
|
|
HRESULT hr;
|
|
ITypeLib *pTypeLib = NULL;
|
|
|
|
//If Type Info is not cached already - load the library and
|
|
//get the Type Info, then cache it for further access
|
|
if (!m_pCTypeInfo)
|
|
{
|
|
|
|
// Load Type Library.
|
|
hr = LoadRegTypeLib(LIBID_WbemScripting, 1, 0, 0, &pTypeLib);
|
|
if (FAILED(hr))
|
|
{
|
|
// if it wasn't registered, try to load it from the path
|
|
// if this succeeds, it will have registered the type library for us
|
|
// for the next time.
|
|
hr = LoadTypeLib(OLESTR("wbemdisp.tlb"), &pTypeLib);
|
|
if(FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
// Get type information for coclass of the object.
|
|
hr = pTypeLib->GetTypeInfoOfGuid(CLSID_SWbemObjectEx, &m_pCTypeInfo);
|
|
pTypeLib->Release();
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
}
|
|
|
|
//AddRef whenever returning another pointer to this
|
|
m_pCTypeInfo->AddRef();
|
|
*pptinfo = m_pCTypeInfo;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CWbemDispatchMgr::GetIDsOfNames(REFIID iid, //always IID_NULL
|
|
LPWSTR FAR* rgszNames,
|
|
unsigned int cNames,
|
|
LCID lcid,
|
|
DISPID FAR* rgdispid)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
CComPtr<ITypeInfo> pITypeInfo;
|
|
|
|
if (SUCCEEDED(hr = GetTypeInfo(0, lcid, &pITypeInfo)))
|
|
{
|
|
// See if this is a static property or method
|
|
if (FAILED(hr = DispGetIDsOfNames(pITypeInfo,
|
|
rgszNames,
|
|
cNames,
|
|
rgdispid)))
|
|
{
|
|
// Not static - try schema
|
|
if (m_pSchemaCache && FAILED(hr = m_pSchemaCache->GetDispID (rgszNames, cNames, rgdispid)))
|
|
{
|
|
rgdispid[0] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
STDMETHODIMP CWbemDispatchMgr::Invoke(DISPID dispidMember,
|
|
REFIID iid, LCID lcid,
|
|
unsigned short wFlags,
|
|
DISPPARAMS FAR* pdispparams,
|
|
VARIANT FAR* pvarResult,
|
|
EXCEPINFO FAR* pexcepinfo,
|
|
unsigned int FAR* puArgErr)
|
|
{
|
|
HRESULT hr;
|
|
ITypeInfo *pTypeInfo = NULL;
|
|
|
|
//Get the type info
|
|
hr = GetTypeInfo(0, lcid, &pTypeInfo);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
m_hResult = S_OK;
|
|
|
|
CWbemDispID dispId (dispidMember);
|
|
|
|
// Is this a regular dispId
|
|
if (dispId.IsStatic ())
|
|
{
|
|
// Check for inbound NULLs masquerading as defaulted parameters
|
|
if (wFlags & DISPATCH_METHOD)
|
|
MapNulls (pdispparams);
|
|
|
|
hr = DispInvoke((IDispatch *) ((ISWbemObjectEx *)m_pSWbemObject),
|
|
pTypeInfo,
|
|
dispidMember,
|
|
wFlags,
|
|
pdispparams,
|
|
pvarResult,
|
|
pexcepinfo,
|
|
puArgErr
|
|
);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// Try the error handler for this object in case it can handle this
|
|
hr = HandleError (dispidMember, wFlags, pdispparams, pvarResult, puArgErr, hr);
|
|
}
|
|
}
|
|
else if (dispId.IsSchema ())
|
|
{
|
|
//Otherwise - this is a WBEM property or method, so we implement
|
|
//the invocation ourselves...
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (dispId.IsSchemaMethod ()) //WBEM method
|
|
hr = InvokeWbemMethod(dispidMember,
|
|
pdispparams,
|
|
pvarResult);
|
|
else if (dispId.IsSchemaProperty ()) //WBEM property
|
|
hr = InvokeWbemProperty(dispidMember,
|
|
wFlags,
|
|
pdispparams,
|
|
pvarResult,
|
|
pexcepinfo,
|
|
puArgErr);
|
|
else
|
|
hr = DISP_E_MEMBERNOTFOUND;
|
|
|
|
if (FAILED(hr))
|
|
RaiseException (hr);
|
|
}
|
|
|
|
if (FAILED (m_hResult))
|
|
{
|
|
if (NULL != pexcepinfo)
|
|
SetException (pexcepinfo, m_hResult, L"SWbemObjectEx");
|
|
|
|
hr = DISP_E_EXCEPTION;
|
|
}
|
|
|
|
if (pTypeInfo)
|
|
pTypeInfo->Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CWbemDispatchMgr::InvokeWbemProperty(DISPID dispid,
|
|
unsigned short wFlags,
|
|
DISPPARAMS FAR* pdispparams,
|
|
VARIANT FAR* pvarResult,
|
|
EXCEPINFO FAR* pexcepinfo,
|
|
unsigned int FAR* puArgErr)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (m_pSchemaCache)
|
|
{
|
|
BOOL bIsGetOperation = (DISPATCH_PROPERTYGET & wFlags);
|
|
|
|
if (bIsGetOperation)
|
|
{
|
|
//Check that the output parameter is valid
|
|
if (pvarResult == NULL)
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
//Check input parameters
|
|
if ((pdispparams->cArgs < 1) || (pdispparams->cArgs > 2))
|
|
return DISP_E_BADPARAMCOUNT;
|
|
|
|
if ((pdispparams->cNamedArgs != 1) ||
|
|
(pdispparams->cNamedArgs == 1 &&
|
|
pdispparams->rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
|
|
return DISP_E_PARAMNOTOPTIONAL;
|
|
}
|
|
|
|
//For both get & put, we need to first get the property
|
|
// (for put we need to validate the syntax)
|
|
CComBSTR bsPropertyName;
|
|
|
|
if (m_pSchemaCache->GetName (dispid, bsPropertyName))
|
|
{
|
|
SAFEARRAY *psaNames = NULL;
|
|
long inx;
|
|
VARIANT vPropVal;
|
|
long lArrayPropInx;
|
|
CIMTYPE lPropType;
|
|
|
|
//Get the value of this property
|
|
//-------------------------------------
|
|
VariantInit(&vPropVal);
|
|
if (FAILED (hr = m_pWbemObject->Get(bsPropertyName, 0, &vPropVal, &lPropType, NULL)))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
// The expected VT type for the proposed property value
|
|
VARTYPE expectedVarType = CimTypeToVtType (lPropType & ~CIM_FLAG_ARRAY);
|
|
|
|
//If we are in a get operation
|
|
//----------------------------------
|
|
if (bIsGetOperation)
|
|
{
|
|
//If the property is an embedded object, we might need to convert it from
|
|
//a VT_UNKNOWN to a VT_DISPATCH
|
|
if (SUCCEEDED(hr = MapFromCIMOMObject(m_pWbemServices, &vPropVal,
|
|
m_pSWbemObject, bsPropertyName)))
|
|
{
|
|
//If the property is an array, need to check for index and get that element
|
|
if ((lPropType & CIM_FLAG_ARRAY) && (pdispparams->cArgs > 0))
|
|
{
|
|
//Note: currently we support single dimension arrays only, so we only
|
|
// look for one index
|
|
VARIANT indexVar;
|
|
VariantInit (&indexVar);
|
|
// Attempt to coerce the index argument into a value suitable for an array index
|
|
if (S_OK == VariantChangeType (&indexVar, &pdispparams->rgvarg[0], 0, VT_I4))
|
|
{
|
|
lArrayPropInx = V_I4(&indexVar);
|
|
|
|
//Fill in the result variant with the requested array element
|
|
hr = assignArrayElementToVariant(vPropVal.parray, (V_VT(&vPropVal) & ~VT_ARRAY),
|
|
lArrayPropInx, pvarResult);
|
|
}
|
|
else
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
|
|
VariantClear (&indexVar);
|
|
}
|
|
else //If it's not an array index - copy to output param and we're done
|
|
{
|
|
// Check if it's an array value and convert as necessary
|
|
if (V_ISARRAY(&vPropVal))
|
|
hr = ConvertArrayRev(pvarResult, &vPropVal);
|
|
else
|
|
hr = VariantCopy (pvarResult, &vPropVal);
|
|
}
|
|
}
|
|
} //Property Get
|
|
|
|
//Otherwise (put operation)
|
|
//---------------------------------
|
|
else
|
|
{
|
|
/*
|
|
* Need to translate this into a call to SWbemProperty.put_Value: easiest way
|
|
* to do this is to
|
|
* (A) get the SWbemProperty object for this property
|
|
* (B) Call IDispatch::Invoke on that object, passing in the value
|
|
* This way we get the error handling behavior too.
|
|
*/
|
|
|
|
CComPtr<ISWbemPropertySet> pISWbemPropertySet;
|
|
|
|
if (SUCCEEDED(hr = m_pSWbemObject->get_Properties_ (&pISWbemPropertySet)))
|
|
{
|
|
CComPtr<ISWbemProperty> pISWbemProperty;
|
|
|
|
if (SUCCEEDED(hr = pISWbemPropertySet->Item (bsPropertyName, 0, &pISWbemProperty)))
|
|
{
|
|
// NB: The Value property of ISWbemProperty is the "default" automation property
|
|
hr = pISWbemProperty->Invoke (
|
|
DISPID_VALUE,
|
|
IID_NULL,
|
|
0,
|
|
wFlags,
|
|
pdispparams,
|
|
pvarResult,
|
|
pexcepinfo,
|
|
puArgErr);
|
|
|
|
// Use our more specific error here if we have one
|
|
if (FAILED(hr) && pexcepinfo)
|
|
hr = pexcepinfo->scode;
|
|
}
|
|
}
|
|
|
|
} //Property Put
|
|
|
|
VariantClear(&vPropVal);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::InvokeWbemMethod
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Invoke the method via direct access.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// dispid The dispid od the method
|
|
// pdispparams Pointer to DISPPARAMS for this invocation
|
|
// pvarResult On successful return holds return value (if any)
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::InvokeWbemMethod(
|
|
DISPID dispid,
|
|
DISPPARAMS FAR* pdispparams,
|
|
VARIANT FAR* pvarResult
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (m_pWbemServices && m_pSchemaCache)
|
|
{
|
|
//Currently we don't support named arguments
|
|
if (pdispparams->cNamedArgs > 0)
|
|
return DISP_E_NONAMEDARGS;
|
|
|
|
//Map the dispid to a method name
|
|
CComBSTR bsMethodName;
|
|
|
|
if (m_pSchemaCache->GetName (dispid, bsMethodName))
|
|
{
|
|
// Build up the inparameters (if any)
|
|
CComPtr<IWbemClassObject> pInParameters;
|
|
CComPtr<IWbemClassObject> pOutParameters;
|
|
|
|
//Get the input parameters object of the method (may be NULL)
|
|
if (SUCCEEDED (hr = m_pWbemClass->GetMethod(bsMethodName, 0, &pInParameters,
|
|
&pOutParameters)))
|
|
{
|
|
CComPtr<IWbemClassObject> pInParamsInstance;
|
|
|
|
if (pInParameters)
|
|
hr = MapInParameters (pdispparams, pInParameters, &pInParamsInstance);
|
|
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
CComPtr<IWbemServices> pService = m_pWbemServices->GetIWbemServices ();
|
|
|
|
if (pService)
|
|
{
|
|
// Need the RELPATH to specify the target class or instance
|
|
VARIANT vObjectPathVal;
|
|
VariantInit(&vObjectPathVal);
|
|
|
|
if (SUCCEEDED (hr = m_pWbemObject->Get
|
|
(WBEMS_SP_RELPATH, 0, &vObjectPathVal, NULL, NULL)))
|
|
{
|
|
/*
|
|
* If a "keyless" object slips through the net its __RELPATH
|
|
* value will be VT_NULL. At this point we should fail gracefully.
|
|
*/
|
|
if (VT_BSTR == V_VT(&vObjectPathVal))
|
|
{
|
|
// Execute the CIMOM method
|
|
CComPtr<IWbemClassObject> pOutParamsInstance;
|
|
|
|
bool needToResetSecurity = false;
|
|
HANDLE hThreadToken = NULL;
|
|
CSWbemSecurity *pSecurityInfo = m_pWbemServices->GetSecurityInfo ();
|
|
|
|
if (pSecurityInfo && pSecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
|
|
{
|
|
|
|
if (SUCCEEDED(hr = pService->ExecMethod(V_BSTR(&vObjectPathVal),
|
|
bsMethodName, 0, NULL,
|
|
pInParamsInstance, &pOutParamsInstance, NULL)))
|
|
hr = MapOutParameters (pdispparams, pOutParameters,
|
|
pOutParamsInstance, pvarResult);
|
|
|
|
SetWbemError (m_pWbemServices);
|
|
}
|
|
|
|
if (pSecurityInfo)
|
|
{
|
|
// Restore original privileges on this thread
|
|
if (needToResetSecurity)
|
|
pSecurityInfo->ResetSecurity (hThreadToken);
|
|
|
|
pSecurityInfo->Release ();
|
|
}
|
|
}
|
|
else
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
|
|
VariantClear (&vObjectPathVal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::MapOutParameters
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Invoke the method via direct access.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// dispparams Pointer to DISPPARAMS for this invocation
|
|
// pOutParameters Class template for out parameters
|
|
// pOutParamsInstance Addresses the IWbemClassObject to hold the
|
|
// out parameters (if any) - may be NULL
|
|
// pvarResult On successful return holds return value (if any)
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::MapOutParameters (
|
|
DISPPARAMS FAR* pdispparams,
|
|
IWbemClassObject *pOutParameters,
|
|
IWbemClassObject *pOutParamsInstance,
|
|
VARIANT FAR* pvarResult
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//For each "out" parameter in the output parameters object (if there is one),
|
|
//find it's id, then look for the parameter with this id in the arguments array
|
|
//and set the return parameter value accordingly
|
|
//----------------------------------------------------------------------------
|
|
|
|
if (pOutParameters && pOutParamsInstance)
|
|
{
|
|
//Start an enumeration through the "out" parameters class template
|
|
if (SUCCEEDED (hr = pOutParameters->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY)))
|
|
{
|
|
BSTR bstrId = SysAllocString(L"id");
|
|
BSTR bstrParamName = NULL;
|
|
|
|
/*
|
|
* For each property in the outparams class template, get the [id]
|
|
* to map the relevant posistional value in the pdispparams.
|
|
*/
|
|
while (WBEM_S_NO_ERROR ==
|
|
(hr != pOutParameters->Next(0, &bstrParamName, NULL, NULL, NULL)))
|
|
{
|
|
// Get the returned parameter value from the instance
|
|
VARIANT vParamVal;
|
|
VariantInit(&vParamVal);
|
|
|
|
if (SUCCEEDED (pOutParamsInstance->Get (bstrParamName, 0, &vParamVal, NULL, NULL)))
|
|
{
|
|
//If this is the return value, set it separately
|
|
if (!_wcsicmp(bstrParamName, L"ReturnValue"))
|
|
{
|
|
if (pvarResult)
|
|
hr = MapReturnValue (pvarResult, &vParamVal);
|
|
}
|
|
//Otherwise - regular out parameter
|
|
else
|
|
{
|
|
IWbemQualifierSet *pQualSet = NULL;
|
|
|
|
//Get the id of this parameter (it's the "id" qualifier)
|
|
if (SUCCEEDED (hr = pOutParameters->GetPropertyQualifierSet
|
|
(bstrParamName, &pQualSet)))
|
|
{
|
|
VARIANT vIdVal;
|
|
VariantInit(&vIdVal);
|
|
|
|
if (SUCCEEDED (hr = pQualSet->Get(bstrId, 0, &vIdVal, NULL)))
|
|
{
|
|
//Calculate the position of this id in the arguments array
|
|
long pos = (pdispparams->cArgs - 1) - V_I4(&vIdVal);
|
|
|
|
// If its out of range, too bad
|
|
if ((0 <= pos) && (pos < (long) pdispparams->cArgs))
|
|
hr = MapOutParameter (&pdispparams->rgvarg[pos], &vParamVal);
|
|
}
|
|
|
|
VariantClear(&vIdVal);
|
|
pQualSet->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
VariantClear (&vParamVal);
|
|
SysFreeString (bstrParamName);
|
|
bstrParamName = NULL;
|
|
} //while
|
|
|
|
SysFreeString (bstrId);
|
|
}
|
|
} //if pOutParameters
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::MapReturnValue
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Map the method return value
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pDest On successful return holds return value (if any)
|
|
// pSrc The variant value to map
|
|
//
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::MapReturnValue (
|
|
VARIANT FAR* pDest,
|
|
VARIANT FAR* pSrc
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//If the return value is a VT_UNKNOWN, we need to wrap into a
|
|
//VT_DISPATCH before passing it back
|
|
if (SUCCEEDED (hr = MapFromCIMOMObject(m_pWbemServices, pSrc)))
|
|
{
|
|
// Handle arrays correctly (must always be VT_ARRAY|VT_VARIANT)
|
|
if(V_VT(pSrc) & VT_ARRAY)
|
|
hr = ConvertArrayRev(pDest, pSrc);
|
|
else
|
|
hr = VariantCopy (pDest, pSrc);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::MapOutParameter
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Map a (possibly by reference) out parameter
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pDest On successful return holds return value (if any)
|
|
// pVal The variant value to map
|
|
//
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::MapOutParameter (
|
|
VARIANT FAR* pDest,
|
|
VARIANT FAR* pSrc
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//If the return value is a VT_UNKNOWN, we need to wrap into a
|
|
//VT_DISPATCH before passing it back
|
|
if (SUCCEEDED (hr = MapFromCIMOMObject(m_pWbemServices, pSrc)))
|
|
{
|
|
VARIANT tempVal;
|
|
VariantInit (&tempVal);
|
|
|
|
// Handle arrays correctly (must always be VT_ARRAY|VT_VARIANT)
|
|
if(V_VT(pSrc) & VT_ARRAY)
|
|
hr = ConvertArrayRev(&tempVal, pSrc);
|
|
else
|
|
hr = VariantCopy (&tempVal, pSrc);
|
|
|
|
// Finally take care of ensuring we produce BYREFs if necessary
|
|
if (SUCCEEDED (hr))
|
|
hr = VariantChangeByValToByRef(pDest, &tempVal, V_VT(pDest));
|
|
|
|
VariantClear (&tempVal);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::MapInParameters
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Map the in parameters to a method
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pdispparams DISPPARAMS containing the in parameters
|
|
// pInParameters Class template for method input parameters
|
|
// ppInParamsInstance On successful return holds the mapped parameters
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::MapInParameters (
|
|
DISPPARAMS FAR* pdispparams,
|
|
IWbemClassObject *pInParameters,
|
|
IWbemClassObject **ppInParamsInstance
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
*ppInParamsInstance = NULL;
|
|
|
|
//Spawn an instance to fill in with values
|
|
if (SUCCEEDED (hr = pInParameters->SpawnInstance(0, ppInParamsInstance)))
|
|
{
|
|
/*
|
|
* Iterate through the "in" parameters object properties in the class to find the
|
|
* ID positional qualifier. Note we do this in the InParams class rather than
|
|
* the spawned instance to protect ourselves against the case where the [id]
|
|
* qualifier has been declared without the "propagate to instance" flavor setting,
|
|
*/
|
|
if (SUCCEEDED (hr = pInParameters->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY)))
|
|
{
|
|
BSTR bstrParamName = NULL;
|
|
BSTR bstrId = SysAllocString(L"id");
|
|
CIMTYPE lType;
|
|
|
|
//For each property in the inparams object
|
|
while (WBEM_S_NO_ERROR ==
|
|
(hr = pInParameters->Next(0, &bstrParamName, NULL, &lType, NULL)))
|
|
{
|
|
IWbemQualifierSet *pQualSet = NULL;
|
|
|
|
//Get the id of this parameter (it's the "id" qualifier)
|
|
if (SUCCEEDED(hr =
|
|
pInParameters->GetPropertyQualifierSet(bstrParamName, &pQualSet)))
|
|
{
|
|
VARIANT vIdVal;
|
|
VariantInit(&vIdVal);
|
|
|
|
if (SUCCEEDED(hr = pQualSet->Get(bstrId, 0, &vIdVal, NULL)))
|
|
{
|
|
//Calculate the position of this id in the arguments array
|
|
long pos = (pdispparams->cArgs - 1) - V_I4(&vIdVal);
|
|
|
|
// If no argument specified, we won't set it in ppInParamsInstance
|
|
// and just assume it will be defaulted
|
|
if ((0 <= pos) && (pos < (long) pdispparams->cArgs))
|
|
{
|
|
VARIANT vParamVal;
|
|
VariantInit (&vParamVal);
|
|
|
|
if (SUCCEEDED (hr = MapInParameter
|
|
(&vParamVal, &pdispparams->rgvarg[pos], lType)))
|
|
{
|
|
// If we have a VT_ERROR with DISP_E_PARAMNOTFOUND this
|
|
// is a "missing" parameter - we just fail to set it and
|
|
// let it default in the instance
|
|
|
|
if ((VT_ERROR == V_VT(&vParamVal)) && (DISP_E_PARAMNOTFOUND == vParamVal.scode))
|
|
{
|
|
// Let it default
|
|
}
|
|
else
|
|
{
|
|
//Copy the value for this parameter from the argument array
|
|
//into the inparamsinstance object property
|
|
hr = (*ppInParamsInstance)->Put(bstrParamName, 0, &vParamVal, NULL);
|
|
}
|
|
}
|
|
|
|
VariantClear (&vParamVal);
|
|
}
|
|
}
|
|
|
|
VariantClear(&vIdVal);
|
|
pQualSet->Release();
|
|
pQualSet = NULL;
|
|
}
|
|
|
|
SysFreeString (bstrParamName);
|
|
bstrParamName = NULL;
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
} //while
|
|
|
|
SysFreeString (bstrId);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::MapInParameter
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Map a in parameter
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pDest On successful return holds return value
|
|
// pVal The variant value to map
|
|
// lType CIMTYPE of target property value
|
|
//
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::MapInParameter (
|
|
VARIANT FAR* pDest,
|
|
VARIANT FAR* pSrc,
|
|
CIMTYPE lType
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if ((NULL == pSrc) || (VT_EMPTY == V_VT(pSrc))
|
|
|| (VT_NULL == V_VT(pSrc)))
|
|
{
|
|
// Map all of these to a VT_NULL
|
|
pDest->vt = VT_NULL;
|
|
}
|
|
else if (((VT_ARRAY | VT_VARIANT) == V_VT(pSrc)) ||
|
|
((VT_ARRAY | VT_VARIANT | VT_BYREF) == V_VT(pSrc)))
|
|
{
|
|
// Arrays need to be mapped "down" to their raw form (and watch out
|
|
// for embedded objects!)
|
|
if (SUCCEEDED(hr = ConvertArray(pDest, pSrc)))
|
|
hr = MapToCIMOMObject(pDest);
|
|
}
|
|
else if ((CIM_FLAG_ARRAY & lType) &&
|
|
((VT_DISPATCH == V_VT(pSrc))
|
|
|| ((VT_DISPATCH|VT_BYREF) == V_VT(pSrc))))
|
|
{
|
|
// Look for a JScript-style IDispatch that needs to be mapped to an array
|
|
hr = ConvertDispatchToArray (pDest, pSrc, lType & ~CIM_FLAG_ARRAY);
|
|
}
|
|
else if ((VT_BYREF | VT_VARIANT) == V_VT(pSrc))
|
|
{
|
|
// May be used if the scripting language supports functions that can change
|
|
// the type of a reference. CIMOM won't do this, wo we unwrap the
|
|
// variant before proceeding
|
|
hr = MapInParameter (pDest, pSrc->pvarVal, lType);
|
|
}
|
|
else
|
|
{
|
|
// A "straightforward" value - all we have to watch for is an embedded object
|
|
// and a possible byRef
|
|
if (SUCCEEDED(hr = VariantCopy (pDest, pSrc)))
|
|
{
|
|
hr = MapToCIMOMObject(pDest);
|
|
|
|
// Is it byref - if so remove the indirection
|
|
if (VT_BYREF & V_VT(pDest))
|
|
hr = VariantChangeType(pDest, pDest, 0, V_VT(pDest) & ~VT_BYREF);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
// CWbemDispatchMgr::RaiseException
|
|
//
|
|
// Description : signal exception to automation client
|
|
//
|
|
// Parameters : hr - HRESULT
|
|
//-------------------------------------------------------------
|
|
void CWbemDispatchMgr::RaiseException (HRESULT hr)
|
|
{
|
|
// Store the HRESULT for processing in the Invoke routine
|
|
m_hResult = hr;
|
|
|
|
// Set a WMI scripting error on this thread for the client
|
|
ICreateErrorInfo *pCreateErrorInfo = NULL;
|
|
|
|
if (SUCCEEDED (CreateErrorInfo (&pCreateErrorInfo)))
|
|
{
|
|
BSTR bsDescr = MapHresultToWmiDescription (hr);
|
|
pCreateErrorInfo->SetDescription (bsDescr);
|
|
SysFreeString (bsDescr);
|
|
pCreateErrorInfo->SetGUID (IID_ISWbemObjectEx);
|
|
pCreateErrorInfo->SetSource (L"SWbemObjectEx");
|
|
|
|
IErrorInfo *pErrorInfo = NULL;
|
|
|
|
if (SUCCEEDED (pCreateErrorInfo->QueryInterface(IID_IErrorInfo, (void**) &pErrorInfo)))
|
|
{
|
|
SetErrorInfo (0, pErrorInfo);
|
|
pErrorInfo->Release ();
|
|
}
|
|
|
|
pCreateErrorInfo->Release ();
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
// Name : assignArrayElementToVariant
|
|
//
|
|
// Description : According to the type of the array elements,
|
|
// retrieves the requested element from the array
|
|
// into a variant
|
|
//
|
|
// Parameters : psa - pointer to the SAFEARRAY
|
|
// vt - vartype of array elements
|
|
// inx - index of the element in the array
|
|
// pvResult - resulting variant
|
|
//-------------------------------------------------------------
|
|
HRESULT assignArrayElementToVariant(SAFEARRAY *psa, VARTYPE vt, long inx, VARIANT *pvResult)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
switch (vt)
|
|
{
|
|
case VT_I2 :
|
|
V_VT(pvResult) = VT_I2;
|
|
SafeArrayGetElement(psa, &inx, &V_I2(pvResult));
|
|
break;
|
|
case VT_I4 :
|
|
V_VT(pvResult) = VT_I4;
|
|
SafeArrayGetElement(psa, &inx, &V_I4(pvResult));
|
|
break;
|
|
case VT_R4 :
|
|
V_VT(pvResult) = VT_R4;
|
|
SafeArrayGetElement(psa, &inx, &V_R4(pvResult));
|
|
break;
|
|
case VT_R8 :
|
|
V_VT(pvResult) = VT_R8;
|
|
SafeArrayGetElement(psa, &inx, &V_R8(pvResult));
|
|
break;
|
|
case VT_DATE :
|
|
V_VT(pvResult) = VT_DATE;
|
|
SafeArrayGetElement(psa, &inx, &V_DATE(pvResult));
|
|
break;
|
|
case VT_BSTR :
|
|
V_VT(pvResult) = VT_BSTR;
|
|
SafeArrayGetElement(psa, &inx, &V_BSTR(pvResult));
|
|
break;
|
|
case VT_DISPATCH :
|
|
V_VT(pvResult) = VT_DISPATCH;
|
|
SafeArrayGetElement(psa, &inx, &V_DISPATCH(pvResult));
|
|
break;
|
|
case VT_UNKNOWN :
|
|
V_VT(pvResult) = VT_UNKNOWN;
|
|
SafeArrayGetElement(psa, &inx, &V_UNKNOWN(pvResult));
|
|
break;
|
|
case VT_BOOL :
|
|
V_VT(pvResult) = VT_BOOL;
|
|
SafeArrayGetElement(psa, &inx, &V_BOOL(pvResult));
|
|
break;
|
|
case VT_VARIANT :
|
|
{
|
|
V_VT(pvResult) = VT_BYREF | VT_VARIANT;
|
|
VARIANT *pVar = new VARIANT;
|
|
|
|
if (pVar)
|
|
{
|
|
VariantInit (pVar);
|
|
SafeArrayGetElement(psa, &inx, pVar);
|
|
V_VARIANTREF(pvResult) = pVar;
|
|
}
|
|
else
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
break;
|
|
case VT_UI1 :
|
|
V_VT(pvResult) = VT_UI1;
|
|
SafeArrayGetElement(psa, &inx, &V_UI1(pvResult));
|
|
break;
|
|
default :
|
|
V_VT(pvResult) = VT_ERROR;
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
// Name : CheckArrayBounds
|
|
//
|
|
// Description : Check that index is within bounds and if not
|
|
// Redim the array
|
|
//
|
|
// Parameters : psa - pointer to the SAFEARRAY
|
|
// inx - putative index
|
|
//-------------------------------------------------------------
|
|
void CheckArrayBounds(SAFEARRAY *psa, long inx)
|
|
{
|
|
long lBound, uBound;
|
|
SafeArrayGetUBound (psa, 1, &uBound);
|
|
SafeArrayGetLBound (psa, 1, &lBound);
|
|
|
|
if ((inx < lBound) || (inx > uBound))
|
|
{
|
|
// Need to redim
|
|
SAFEARRAYBOUND psaBound;
|
|
|
|
psaBound.cElements = ((inx < lBound) ?
|
|
(uBound + 1 - inx) : (inx + 1 - lBound));
|
|
|
|
psaBound.lLbound = (inx < lBound) ? inx : lBound;
|
|
SafeArrayRedim (psa, &psaBound);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
// Name : assignVariantToArrayElement
|
|
//
|
|
// Description : According to the type of the array elements,
|
|
// puts the new value from the variant into the
|
|
// requested element of the array
|
|
//
|
|
// Parameters : psa - pointer to the SAFEARRAY
|
|
// vt - vartype of array elements
|
|
// inx - index of the element in the array
|
|
// pvNewVal - variant containing the new value
|
|
//-------------------------------------------------------------
|
|
void assignVariantToArrayElement(SAFEARRAY *psa, VARTYPE vt, long inx, VARIANT *pvNewVal)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// Firstly check for out-of-bounds case and grow accordingly
|
|
CheckArrayBounds (psa, inx);
|
|
|
|
switch (vt)
|
|
{
|
|
case VT_I2 :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_I2(pvNewVal));
|
|
break;
|
|
case VT_I4 :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_I4(pvNewVal));
|
|
break;
|
|
case VT_R4 :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_R4(pvNewVal));
|
|
break;
|
|
case VT_R8 :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_R8(pvNewVal));
|
|
break;
|
|
case VT_DATE :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_DATE(pvNewVal));
|
|
break;
|
|
case VT_BSTR :
|
|
hr = SafeArrayPutElement(psa, &inx, V_BSTR(pvNewVal));
|
|
break;
|
|
case VT_DISPATCH :
|
|
hr = SafeArrayPutElement(psa, &inx, V_DISPATCH(pvNewVal));
|
|
break;
|
|
case VT_UNKNOWN:
|
|
hr = SafeArrayPutElement(psa, &inx, V_UNKNOWN(pvNewVal));
|
|
break;
|
|
case VT_BOOL :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_BOOL(pvNewVal));
|
|
break;
|
|
case VT_VARIANT :
|
|
hr = SafeArrayPutElement(psa, &inx, V_VARIANTREF(pvNewVal));
|
|
break;
|
|
case VT_UI1 :
|
|
hr = SafeArrayPutElement(psa, &inx, &V_UI1(pvNewVal));
|
|
break;
|
|
default :
|
|
//????????????
|
|
break;
|
|
} //switch
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------
|
|
// Name : CimTypeToVtType
|
|
//
|
|
// Description : Returns the coresponding VARTYPE for
|
|
// a given CIMTYPE
|
|
// Parameters : lType - the CIMTYPE we want to convert
|
|
//-------------------------------------------------------------
|
|
VARTYPE CimTypeToVtType(CIMTYPE lType)
|
|
{
|
|
VARTYPE ret = VT_EMPTY;
|
|
|
|
if (lType & CIM_FLAG_ARRAY)
|
|
ret = VT_ARRAY;
|
|
|
|
switch(lType & ~CIM_FLAG_ARRAY)
|
|
{
|
|
case CIM_EMPTY : ret = (ret | VT_EMPTY); break;
|
|
case CIM_SINT8 : ret = (ret | VT_I2); break;
|
|
case CIM_UINT8 : ret = (ret | VT_UI1); break;
|
|
case CIM_SINT16 : ret = (ret | VT_I2); break;
|
|
case CIM_UINT16 : ret = (ret | VT_I4); break;
|
|
case CIM_SINT32 : ret = (ret | VT_I4); break;
|
|
case CIM_UINT32 : ret = (ret | VT_I4); break;
|
|
case CIM_SINT64 : ret = (ret | VT_BSTR); break;
|
|
case CIM_UINT64 : ret = (ret | VT_BSTR); break;
|
|
case CIM_REAL32 : ret = (ret | VT_R4); break;
|
|
case CIM_REAL64 : ret = (ret | VT_R8); break;
|
|
case CIM_BOOLEAN : ret = (ret | VT_BOOL); break;
|
|
case CIM_STRING : ret = (ret | VT_BSTR); break;
|
|
case CIM_DATETIME : ret = (ret | VT_BSTR); break;
|
|
case CIM_REFERENCE :ret = (ret | VT_BSTR); break;
|
|
case CIM_CHAR16 : ret = (ret | VT_I2); break;
|
|
case CIM_OBJECT : ret = (ret | VT_UNKNOWN); break;
|
|
default : ret = VT_ERROR;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------
|
|
// Name : VariantChangeByValToByRef
|
|
//
|
|
// Description : Copies a variant, while converting a "byval" to a
|
|
// "byref" if the destination type requires it
|
|
//
|
|
// Parameters : dest - destination variant to hold the result
|
|
// source - source variant to be copied
|
|
// destType - the VARTYPE required for the result.
|
|
// when this type is a BY_REF, the appropriate
|
|
// conversion is made from the source.
|
|
//-------------------------------------------------------------
|
|
HRESULT VariantChangeByValToByRef(VARIANT *dest, VARIANT *source, VARTYPE destType)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!(destType & VT_BYREF)) //the destination is not by ref. we can do a straight copy
|
|
hr = VariantCopy(dest, source);
|
|
else
|
|
{
|
|
if ((destType & ~VT_BYREF) & VT_ARRAY)
|
|
hr = SafeArrayCopy(V_ARRAY(source), V_ARRAYREF(dest));
|
|
else
|
|
{
|
|
switch (destType & ~VT_BYREF)
|
|
{
|
|
case VT_UI1 : *V_UI1REF(dest) = V_UI1(source); break;
|
|
case VT_I2 : *V_I2REF(dest) = V_I2(source); break;
|
|
case VT_I4 : *V_I4REF(dest) = V_I4(source); break;
|
|
case VT_R4 : *V_R4REF(dest) = V_R4(source); break;
|
|
case VT_R8 : *V_R8REF(dest) = V_R8(source); break;
|
|
case VT_CY : *V_CYREF(dest) = V_CY(source); break;
|
|
case VT_BSTR : SysReAllocString(V_BSTRREF(dest), V_BSTR(source)); break;
|
|
case VT_BOOL : *V_BOOLREF(dest) = V_BOOL(source); break;
|
|
case VT_DATE : *V_DATEREF(dest) = V_DATE(source); break;
|
|
case VT_DISPATCH :
|
|
//I need to addref the object behind this interface so
|
|
//that it doesn't get released when we release the original VARIANT
|
|
//that's holding it
|
|
V_DISPATCH(source)->AddRef();
|
|
*V_DISPATCHREF(dest) = V_DISPATCH(source);
|
|
break;
|
|
case VT_UNKNOWN :
|
|
//Again, need to addref so that the object doesn't get released
|
|
V_UNKNOWN(source)->AddRef();
|
|
*V_UNKNOWNREF(dest) = V_UNKNOWN(source); break;
|
|
break;
|
|
case VT_VARIANT : hr = VariantCopy(V_VARIANTREF(dest), source); break;
|
|
default : hr = DISP_E_TYPEMISMATCH;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// void CWbemDispatchMgr::EnsureClassRetrieved
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Make sure we have a class pointer
|
|
//
|
|
//***************************************************************************
|
|
|
|
void CWbemDispatchMgr::EnsureClassRetrieved ()
|
|
{
|
|
if (!m_pWbemClass)
|
|
{
|
|
CComVariant vGenusVal, vClassName;
|
|
bool bIsClass;
|
|
|
|
if (SUCCEEDED(m_pWbemObject->Get(WBEMS_SP_GENUS, 0, &vGenusVal, NULL, NULL)))
|
|
{
|
|
bIsClass = (WBEM_GENUS_CLASS == vGenusVal.lVal);
|
|
|
|
//If the object is a class, point the class pointer to it as well
|
|
if (bIsClass)
|
|
{
|
|
m_pWbemClass = m_pWbemObject;
|
|
m_pWbemClass->AddRef () ;
|
|
}
|
|
//Otherwise (it's an instance) we need to get the class
|
|
else
|
|
{
|
|
// Check we have an IWbemServices pointer
|
|
|
|
if (m_pWbemServices)
|
|
{
|
|
/*
|
|
* Note we must check that returned value is a BSTR - it could be a VT_NULL if
|
|
* the __CLASS property has not yet been set.
|
|
*/
|
|
|
|
if (SUCCEEDED(m_pWbemObject->Get(WBEMS_SP_CLASS, 0, &vClassName, NULL, NULL))
|
|
&& (VT_BSTR == V_VT(&vClassName)))
|
|
{
|
|
CComPtr<IWbemServices> pIWbemServices = m_pWbemServices->GetIWbemServices ();
|
|
|
|
if (pIWbemServices)
|
|
{
|
|
CSWbemSecurity *pSecurity = m_pWbemServices->GetSecurityInfo ();
|
|
|
|
if (pSecurity)
|
|
{
|
|
bool needToResetSecurity = false;
|
|
HANDLE hThreadToken = NULL;
|
|
|
|
if (pSecurity->SetSecurity (needToResetSecurity, hThreadToken))
|
|
pIWbemServices->GetObject (vClassName.bstrVal, 0, NULL, &m_pWbemClass, NULL);
|
|
|
|
// Restore original privileges on this thread
|
|
if (needToResetSecurity)
|
|
pSecurity->ResetSecurity (hThreadToken);
|
|
|
|
pSecurity->Release ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemDispatchMgr::HandleError
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Provide bespoke handling of error conditions in the bolierplate
|
|
// Dispatch implementation.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// dispidMember, wFlags,
|
|
// pdispparams, pvarResult,
|
|
// puArgErr, All passed directly from IDispatch::Invoke
|
|
// hr The return code from the bolierplate invoke
|
|
//
|
|
// RETURN VALUES:
|
|
// The new return code (to be ultimately returned from Invoke)
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemDispatchMgr::HandleError (
|
|
DISPID dispidMember,
|
|
unsigned short wFlags,
|
|
DISPPARAMS FAR* pdispparams,
|
|
VARIANT FAR* pvarResult,
|
|
UINT FAR* puArgErr,
|
|
HRESULT hr
|
|
)
|
|
{
|
|
/*
|
|
* We are looking for GET calls on the Derivation_ property which
|
|
* supplied an argument. Since this property returns a SAFEARRAY, this may
|
|
* be legal but undetectable by the standard Dispatch mechanism. It is meaningful
|
|
* to pass an index (the interpretation is that the index specifies an offset in
|
|
* the SAFEARRAY structure that represents the derivation value).
|
|
*/
|
|
if ((dispidMember == WBEMS_DISPID_DERIVATION) && (DISP_E_NOTACOLLECTION == hr) && (1 == pdispparams->cArgs)
|
|
&& (DISPATCH_PROPERTYGET & wFlags))
|
|
{
|
|
// Looks promising - get the __DERIVATION property to try and resolve this
|
|
if (m_pWbemObject)
|
|
{
|
|
VARIANT var;
|
|
VariantInit (&var);
|
|
|
|
if (WBEM_S_NO_ERROR == m_pWbemObject->Get (WBEMS_SP_DERIVATION, 0, &var, NULL, NULL))
|
|
{
|
|
/* The value should be a VT_BSTR|VT_ARRAY */
|
|
if (((VT_ARRAY | VT_BSTR) == var.vt) && (NULL != var.parray))
|
|
{
|
|
VARIANT indexVar;
|
|
VariantInit (&indexVar);
|
|
|
|
// Attempt to coerce the index argument into a value suitable for an array index
|
|
if (S_OK == VariantChangeType (&indexVar, &pdispparams->rgvarg[0], 0, VT_I4))
|
|
{
|
|
long lArrayPropInx = V_I4(&indexVar);
|
|
|
|
// We should have a VT_ARRAY|VT_BSTR value at this point; extract the
|
|
// BSTR and set it into the VARIANT
|
|
VariantInit (pvarResult);
|
|
BSTR nameValue = NULL;
|
|
if (SUCCEEDED(hr = SafeArrayGetElement (var.parray, &lArrayPropInx, &nameValue)))
|
|
{
|
|
VariantInit (pvarResult);
|
|
pvarResult->vt = VT_BSTR;
|
|
pvarResult->bstrVal = nameValue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
if (puArgErr)
|
|
*puArgErr = 0;
|
|
}
|
|
|
|
VariantClear (&indexVar);
|
|
}
|
|
}
|
|
|
|
VariantClear (&var);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// IDispatchEx methods
|
|
HRESULT STDMETHODCALLTYPE CWbemDispatchMgr::GetDispID(
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ DWORD grfdex,
|
|
/* [out] */ DISPID __RPC_FAR *pid)
|
|
{
|
|
return GetIDsOfNames(IID_NULL, &((OLECHAR *)bstrName), 1, ENGLISH_LOCALE, pid);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemSchemaIDCache::~CWbemSchemaIDCache
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Destructor
|
|
//
|
|
//***************************************************************************
|
|
|
|
CWbemSchemaIDCache::~CWbemSchemaIDCache ()
|
|
{
|
|
DispIDNameMap::iterator next;
|
|
|
|
while ((next = m_cache.begin ()) != m_cache.end ())
|
|
next = m_cache.erase (next);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CWbemSchemaIDCache::GetDispID
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Attempts to resolves a set of names to DISP IDs based on WMI schema.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// rgszNames Array of names
|
|
// cNames Length of above array
|
|
// rgdispid Pointer to array to hold resolved DISPIDs
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CWbemSchemaIDCache::GetDispID (
|
|
LPWSTR* rgszNames,
|
|
unsigned int cNames,
|
|
DISPID* rgdispid
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (0 < cNames)
|
|
{
|
|
DispIDNameMap::iterator theIterator = m_cache.find (rgszNames [0]);
|
|
|
|
if (theIterator != m_cache.end ())
|
|
{
|
|
hr = S_OK;
|
|
rgdispid [0] = (*theIterator).second;
|
|
}
|
|
else
|
|
{
|
|
if ((1 == cNames) && FindPropertyName (rgszNames [0]))
|
|
{
|
|
// Get a new dispid and add it to the cache
|
|
CWbemDispID dispId;
|
|
|
|
if (dispId.SetAsSchemaID (++m_nextId))
|
|
{
|
|
rgdispid [0] = dispId;
|
|
m_cache.insert (DispIDNameMap::value_type (rgszNames [0],
|
|
dispId));
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//If no property name matches, go on to methods
|
|
SAFEARRAY *psaInParams = NULL; //array of in parameters names
|
|
SAFEARRAY *psaOutParams = NULL; //array of out parameter names
|
|
CComPtr<IWbemClassObject> pInParams;
|
|
CComPtr<IWbemClassObject> pOutParams;
|
|
bool bMethodFound = false;
|
|
long id = 0;
|
|
bool bUnknownParameterFound = false;
|
|
|
|
//Get the names of all method parameters (in and out)
|
|
if (GetMethod (rgszNames[0], &psaInParams, &psaOutParams,
|
|
pInParams, pOutParams))
|
|
{
|
|
bMethodFound = true;
|
|
unsigned long ulParamCount;
|
|
bool ok = true;
|
|
|
|
//For each named parameter, search for it in the method parameters
|
|
for (ulParamCount=1; ok && (ulParamCount < cNames); ulParamCount++)
|
|
{
|
|
//If we find this name in the "in" parameters list, attach the id and go on
|
|
if (psaInParams && FindMemberInArray(rgszNames[ulParamCount], psaInParams))
|
|
{
|
|
if (GetIdOfMethodParameter(rgszNames[ulParamCount], //param name
|
|
pInParams,
|
|
&id))
|
|
rgdispid[ulParamCount] = id;
|
|
else
|
|
ok = false;
|
|
}
|
|
//If it's not in the "in" parameters, check the "out" parameters list
|
|
else if (psaOutParams && FindMemberInArray(rgszNames[ulParamCount], psaOutParams))
|
|
{
|
|
if (GetIdOfMethodParameter(rgszNames[ulParamCount], //param name
|
|
pOutParams,
|
|
&id))
|
|
rgdispid[ulParamCount] = id;
|
|
else
|
|
ok = false;
|
|
}
|
|
//If it's not there either - we can't find it
|
|
else
|
|
{
|
|
rgdispid[ulParamCount] = DISPID_UNKNOWN;
|
|
bUnknownParameterFound = true;
|
|
}
|
|
} //walk parameters
|
|
|
|
if (!ok)
|
|
bMethodFound = false;
|
|
}
|
|
|
|
if (psaInParams)
|
|
SafeArrayDestroy(psaInParams);
|
|
|
|
if (psaOutParams)
|
|
SafeArrayDestroy(psaOutParams);
|
|
|
|
if (!bMethodFound)
|
|
hr = E_FAIL;
|
|
else if (bUnknownParameterFound)
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
else
|
|
hr = S_OK;
|
|
|
|
// Finally, if this all worked add it to the cache as a method
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CWbemDispID dispId;
|
|
|
|
if (dispId.SetAsSchemaID (++m_nextId, false))
|
|
{
|
|
rgdispid [0] = dispId;
|
|
m_cache.insert (DispIDNameMap::value_type (rgszNames [0],
|
|
dispId));
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
// bool CWbemSchemaIDCache::FindPropertyName
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Determine whether the property exists for this object and is not
|
|
// a system property
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// bsName - name of specified property
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
bool CWbemSchemaIDCache::FindPropertyName(
|
|
BSTR bsName
|
|
)
|
|
{
|
|
bool result = false;;
|
|
|
|
if (m_pDispatchMgr)
|
|
{
|
|
CComPtr<IWbemClassObject> pIWbemClassObject = m_pDispatchMgr->GetObject ();
|
|
|
|
if (pIWbemClassObject)
|
|
{
|
|
//Note : This limits the support to non-system properties only !!!
|
|
LONG lFlavor = 0;
|
|
|
|
if (SUCCEEDED(pIWbemClassObject->Get(bsName, 0, NULL, NULL, &lFlavor))
|
|
&& !(WBEM_FLAVOR_ORIGIN_SYSTEM & lFlavor))
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// bool CWbemSchemaIDCache::GetMethod
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// returns the parameter names of a method in two
|
|
// safearrays - one for in and one for out
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// bstrMethodName - name of method requested
|
|
// ppsaInParams - pointer to safearray to return
|
|
// in parameters
|
|
// ppsaOutParams - pointer to safearray to return
|
|
// out parameters
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
bool CWbemSchemaIDCache::GetMethod(
|
|
BSTR bstrMethodName,
|
|
SAFEARRAY **ppsaInParams,
|
|
SAFEARRAY **ppsaOutParams,
|
|
CComPtr<IWbemClassObject> & pInParamsObject,
|
|
CComPtr<IWbemClassObject> & pOutParamsObject
|
|
)
|
|
{
|
|
bool result = false;
|
|
CComPtr<IWbemClassObject> pIWbemClassObject = m_pDispatchMgr->GetClassObject ();
|
|
|
|
if (pIWbemClassObject)
|
|
{
|
|
if (SUCCEEDED(pIWbemClassObject->GetMethod(bstrMethodName, 0, &pInParamsObject, &pOutParamsObject)))
|
|
{
|
|
*ppsaInParams = NULL;
|
|
*ppsaOutParams = NULL;
|
|
bool ok = true;
|
|
|
|
if (pInParamsObject)
|
|
{
|
|
if (FAILED(pInParamsObject->GetNames(NULL, 0, NULL, ppsaInParams)))
|
|
ok = false;
|
|
}
|
|
|
|
if (ok && pOutParamsObject)
|
|
{
|
|
if (FAILED(pOutParamsObject->GetNames(NULL, 0, NULL, ppsaOutParams)))
|
|
ok = false;
|
|
}
|
|
|
|
result = ok;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// bool CWbemSchemaIDCache::GetIdOfMethodParameter
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// gets the id of a given parameter for a given method
|
|
// (this is a qualifier on the parameter property in the
|
|
// InParameters/OutParameters object)
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// bstrParamName - parameter name
|
|
// pParams - IWbemClassObject containing parameters
|
|
// pId - pointer to long to receive the ID for this
|
|
// parameter of this method
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
bool CWbemSchemaIDCache::GetIdOfMethodParameter(
|
|
BSTR bstrParamName,
|
|
CComPtr<IWbemClassObject> &pParams,
|
|
long *pId
|
|
)
|
|
{
|
|
bool result = false;
|
|
|
|
if (pParams)
|
|
{
|
|
CComPtr<IWbemQualifierSet> pQualSet;
|
|
|
|
//Get qualifier set for the required parameter property
|
|
if (SUCCEEDED(pParams->GetPropertyQualifierSet(bstrParamName, &pQualSet)))
|
|
{
|
|
CComVariant vIdVal;
|
|
|
|
//Get the "id" qualifier value
|
|
if (SUCCEEDED(pQualSet->Get(L"id", 0, &vIdVal, NULL)))
|
|
{
|
|
result = true;
|
|
*pId = vIdVal.lVal;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// bool CWbemSchemaIDCache::GetName
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// gets the name of the item given a DISPID
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// dispId - id whose name we require
|
|
// bsName - the name (on successful return)
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
//***************************************************************************
|
|
|
|
bool CWbemSchemaIDCache::GetName (
|
|
DISPID dispId,
|
|
CComBSTR & bsName
|
|
)
|
|
{
|
|
bool result = false;
|
|
|
|
DispIDNameMap::iterator theIterator = m_cache.begin ();
|
|
|
|
while (theIterator != m_cache.end ())
|
|
{
|
|
if (dispId == (*theIterator).second)
|
|
{
|
|
bsName = (*theIterator).first;
|
|
result = true;
|
|
break;
|
|
}
|
|
else
|
|
theIterator++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// bool CWbemSchemaIDCache::FindMemberInArray
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// determine whether a name is present in a SAFEARRAY
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// bstrName - the name we're looking for
|
|
// psaNames - SAFEARRAY we're looking in
|
|
//
|
|
// RETURN VALUES:
|
|
// true if found, false o/w
|
|
//
|
|
//***************************************************************************
|
|
|
|
bool CWbemSchemaIDCache::FindMemberInArray(BSTR bstrName, SAFEARRAY *psaNames)
|
|
{
|
|
long lUBound;
|
|
long i;
|
|
|
|
//Walk the array and check if the requested name exists
|
|
SafeArrayGetUBound(psaNames, 1, &lUBound);
|
|
|
|
for (i=0; i <= lUBound; i++)
|
|
{
|
|
CComBSTR bstrMemberName;
|
|
SafeArrayGetElement(psaNames, &i, &bstrMemberName);
|
|
|
|
if (!_wcsicmp(bstrMemberName, bstrName)) //found the property
|
|
break;
|
|
}
|
|
|
|
return (i <= lUBound);
|
|
}
|
|
|
|
|