able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/scripting/services.cpp

1615 lines
39 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//***************************************************************************
//
// Copyright (c) 1998-2000 Microsoft Corporation
//
// SERVICES.CPP
//
// alanbos 15-Aug-96 Created.
//
// Defines the implementation of ISWbemServicesEx
//
//***************************************************************************
#include "precomp.h"
//***************************************************************************
//
// CSWbemServices::CSWbemServices
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CSWbemServices::CSWbemServices(
IWbemServices *pService,
BSTR bsNamespacePath,
BSTR bsAuthority,
BSTR bsUser,
BSTR bsPassword,
CWbemLocatorSecurity *pSecurityInfo,
BSTR bsLocale)
: m_SecurityInfo (NULL),
m_pUnsecuredApartment(NULL),
m_bsLocale (NULL),
m_cRef (0),
m_pIServiceProvider (NULL)
{
InterlockedIncrement(&g_cObj);
m_Dispatch.SetObj ((ISWbemServicesEx *)this, IID_ISWbemServicesEx,
CLSID_SWbemServicesEx, L"SWbemServicesEx");
m_SecurityInfo = new CSWbemSecurity (pService,
bsAuthority, bsUser, bsPassword, pSecurityInfo);
if (bsLocale)
m_bsLocale = SysAllocString (bsLocale);
if (bsNamespacePath)
m_bsNamespacePath = bsNamespacePath;
}
//***************************************************************************
//
// CSWbemServices::CSWbemServices
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CSWbemServices::CSWbemServices(
IWbemServices *pService,
BSTR bsNamespacePath,
COAUTHIDENTITY *pCoAuthIdentity,
BSTR bsPrincipal,
BSTR bsAuthority)
: m_SecurityInfo (NULL),
m_pUnsecuredApartment(NULL),
m_bsLocale (NULL),
m_cRef (0),
m_pIServiceProvider (NULL)
{
InterlockedIncrement(&g_cObj);
m_Dispatch.SetObj ((ISWbemServicesEx *)this, IID_ISWbemServicesEx,
CLSID_SWbemServicesEx, L"SWbemServicesEx");
m_SecurityInfo = new CSWbemSecurity (pService, pCoAuthIdentity,
bsPrincipal, bsAuthority);
if (bsNamespacePath)
m_bsNamespacePath = bsNamespacePath;
}
//***************************************************************************
//
// CSWbemServices::CSWbemServices
//
// DESCRIPTION:
//
// Constructor: used to clone a new CSWbemServices from an exisiting
// instance. The security info object is copied from the original instance
// (which clones the underlying proxy), and the security settings are modified
// appropriately if an override security instance is also passed in. This
// constructor is used when creating a CSWbemObject.
//
//***************************************************************************
CSWbemServices::CSWbemServices(
CSWbemServices *pService,
CSWbemSecurity *pSecurity)
: m_SecurityInfo (NULL),
m_pUnsecuredApartment(NULL),
m_bsLocale (NULL),
m_cRef (0),
m_pIServiceProvider (NULL)
{
InterlockedIncrement(&g_cObj);
m_Dispatch.SetObj ((ISWbemServicesEx *)this, IID_ISWbemServicesEx,
CLSID_SWbemServicesEx, L"SWbemServicesEx");
if (pService)
{
/*
* Make a new security object from the one contained in the original
* CSWbemServices. Note that this will copy the IWbemServices proxy
* so we have an independently securable proxy for this new object.
*/
CSWbemSecurity *pServiceSecurity = pService->GetSecurityInfo ();
if (pServiceSecurity)
{
m_SecurityInfo = new CSWbemSecurity (pServiceSecurity);
pServiceSecurity->Release ();
}
/*
* If an overriding security pointer was passed in, use its' settings to
* modify our local security pointer.
*/
if (pSecurity)
{
IUnknown *pUnk = pSecurity->GetProxy ();
if (pUnk)
{
if (m_SecurityInfo)
m_SecurityInfo->SecureInterfaceRev (pUnk);
pUnk->Release ();
}
}
// Copy the locale
m_bsLocale = SysAllocString (pService->GetLocale ());
// Copy the path
m_bsNamespacePath = pService->GetPath ();
}
}
//***************************************************************************
//
// CSWbemServices::CSWbemServices
//
// DESCRIPTION:
//
// Constructor: used to clone a new CSWbemServices from an exisiting
// ISWbemInternalServices interface. The security info object is copied from
// the original instance (which clones the underlying proxy). This
// constructor is used when creating a CSWbemRefreshableItem.
//
//***************************************************************************
CSWbemServices::CSWbemServices (
ISWbemInternalServices *pISWbemInternalServices)
: m_SecurityInfo (NULL),
m_pUnsecuredApartment (NULL),
m_bsLocale (NULL),
m_cRef (0),
m_pIServiceProvider (NULL)
{
InterlockedIncrement(&g_cObj);
m_Dispatch.SetObj ((ISWbemServicesEx *)this, IID_ISWbemServicesEx,
CLSID_SWbemServicesEx, L"SWbemServicesEx");
if (pISWbemInternalServices)
{
// Copy the locale
pISWbemInternalServices->GetLocale (&m_bsLocale);
// Copy the path
pISWbemInternalServices->GetNamespacePath (&m_bsNamespacePath);
/*
* Make a new security object from the one contained in the original
* ISWbemServices. Note that this will copy the IWbemServices proxy
* so we have an independently securable proxy for this new object.
*/
ISWbemInternalSecurity *pISWbemInternalSecurity = NULL;
pISWbemInternalServices->GetISWbemInternalSecurity (&pISWbemInternalSecurity);
if (pISWbemInternalSecurity)
{
CComPtr<IWbemServices> pIWbemServices;
if (SUCCEEDED(pISWbemInternalServices->GetIWbemServices (&pIWbemServices)))
{
m_SecurityInfo = new CSWbemSecurity (pIWbemServices,
pISWbemInternalSecurity);
pISWbemInternalSecurity->Release ();
}
}
}
}
//***************************************************************************
//
// CSWbemServices::CSWbemServices
//
// DESCRIPTION:
//
// Constructor: used to build a new CSWbemServices from an IWbemServices
// and a existing CSWbemServices
//
//***************************************************************************
CSWbemServices::CSWbemServices(
IWbemServices *pIWbemServices,
CSWbemServices *pCSWbemServices
) : m_SecurityInfo (NULL),
m_pUnsecuredApartment(NULL),
m_bsLocale (NULL),
m_cRef (0),
m_pIServiceProvider (NULL)
{
InterlockedIncrement(&g_cObj);
m_Dispatch.SetObj ((ISWbemServices *)this, IID_ISWbemServices,
CLSID_SWbemServices, L"SWbemServices");
if (pIWbemServices)
{
// Make a new security cache based on the proxy passed in, but use the
// settings from the existing object
CSWbemSecurity *pSecurity = NULL;
if (pCSWbemServices)
pSecurity = pCSWbemServices->GetSecurityInfo ();
m_SecurityInfo = new CSWbemSecurity (pIWbemServices, pSecurity);
if (pSecurity)
pSecurity->Release ();
// Copy the locale and path
if (pCSWbemServices)
{
m_bsLocale = SysAllocString (pCSWbemServices->GetLocale ());
m_bsNamespacePath = pCSWbemServices->GetPath ();
}
}
}
//***************************************************************************
//
// CSWbemServices::~CSWbemServices
//
// DESCRIPTION:
//
// Destructor.
//
//***************************************************************************
CSWbemServices::~CSWbemServices(void)
{
RELEASEANDNULL(m_SecurityInfo)
FREEANDNULL(m_bsLocale)
RELEASEANDNULL(m_pUnsecuredApartment)
InterlockedDecrement(&g_cObj);
}
IUnsecuredApartment *CSWbemServices::GetCachedUnsecuredApartment()
{
// If we have one just return with it. If not create one.
// This is released in the destructor
if (!m_pUnsecuredApartment)
{
HRESULT hr;
hr = CoCreateInstance(CLSID_UnsecuredApartment, 0, CLSCTX_ALL,
IID_IUnsecuredApartment, (LPVOID *) &m_pUnsecuredApartment);
if (FAILED(hr))
m_pUnsecuredApartment = NULL;
}
// AddRef so caller must release
if (m_pUnsecuredApartment)
m_pUnsecuredApartment->AddRef ();
return m_pUnsecuredApartment;
}
//***************************************************************************
// HRESULT CSWbemServices::QueryInterface
// long CSWbemServices::AddRef
// long CSWbemServices::Release
//
// DESCRIPTION:
//
// Standard Com IUNKNOWN functions.
//
//***************************************************************************
STDMETHODIMP CSWbemServices::QueryInterface (
IN REFIID riid,
OUT LPVOID *ppv
)
{
*ppv = NULL;
if (IID_IUnknown==riid)
*ppv = reinterpret_cast<IUnknown*>(this);
else if (IID_ISWbemServices==riid)
*ppv = (ISWbemServices *)this;
else if (IID_ISWbemServicesEx==riid)
*ppv = (ISWbemServicesEx *)this;
else if (IID_IDispatch==riid)
*ppv = (IDispatch *)((ISWbemServicesEx *)this);
else if (IID_IDispatchEx==riid)
*ppv = (IDispatchEx *)this;
else if (IID_ISupportErrorInfo==riid)
*ppv = (ISupportErrorInfo *)this;
else if (IID_ISWbemInternalServices==riid)
*ppv = (ISWbemInternalServices *)this;
else if (IID_IProvideClassInfo==riid)
*ppv = (IProvideClassInfo *)this;
if (NULL!=*ppv)
{
((LPUNKNOWN)*ppv)->AddRef();
return NOERROR;
}
return ResultFromScode(E_NOINTERFACE);
}
STDMETHODIMP_(ULONG) CSWbemServices::AddRef(void)
{
InterlockedIncrement(&m_cRef);
return m_cRef;
}
STDMETHODIMP_(ULONG) CSWbemServices::Release(void)
{
InterlockedDecrement(&m_cRef);
if (0L!=m_cRef)
return m_cRef;
delete this;
return 0;
}
// IDispatch methods should be inline
STDMETHODIMP CSWbemServices::GetTypeInfoCount(UINT* pctinfo)
{
_RD(static char *me = "CSWbemServices::GetTypeInfoCount()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetTypeInfoCount(pctinfo);}
STDMETHODIMP CSWbemServices::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)
{
_RD(static char *me = "CSWbemServices::GetTypeInfo()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetTypeInfo(itinfo, lcid, pptinfo);}
STDMETHODIMP CSWbemServices::GetIDsOfNames(REFIID riid, OLECHAR** rgszNames,
UINT cNames, LCID lcid, DISPID* rgdispid)
{
_RD(static char *me = "CSWbemServices::GetIdsOfNames()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetIDsOfNames(riid, rgszNames, cNames,
lcid,
rgdispid);}
STDMETHODIMP CSWbemServices::Invoke(DISPID dispidMember, REFIID riid, LCID lcid,
WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
EXCEPINFO* pexcepinfo, UINT* puArgErr)
{
_RD(static char *me = "CSWbemServices::Invoke()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.Invoke(dispidMember, riid, lcid, wFlags,
pdispparams, pvarResult, pexcepinfo, puArgErr);}
// IDispatchEx methods should be inline
HRESULT STDMETHODCALLTYPE CSWbemServices::GetDispID(
/* [in] */ BSTR bstrName,
/* [in] */ DWORD grfdex,
/* [out] */ DISPID __RPC_FAR *pid)
{
_RD(static char *me = "CSWbemServices::GetDispID()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetDispID(bstrName, grfdex, pid);
}
/* [local] */ HRESULT STDMETHODCALLTYPE CSWbemServices::InvokeEx(
/* [in] */ DISPID id,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [in] */ DISPPARAMS __RPC_FAR *pdp,
/* [out] */ VARIANT __RPC_FAR *pvarRes,
/* [out] */ EXCEPINFO __RPC_FAR *pei,
/* [unique][in] */ IServiceProvider __RPC_FAR *pspCaller)
{
HRESULT hr;
_RD(static char *me = "CSWbemServices::InvokeEx()";)
_RPrint(me, "Called", (long)id, "id");
_RPrint(me, "Called", (long)wFlags, "wFlags");
m_pIServiceProvider = pspCaller;
hr = m_Dispatch.InvokeEx(id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
m_pIServiceProvider = NULL;
return hr;
}
HRESULT STDMETHODCALLTYPE CSWbemServices::DeleteMemberByName(
/* [in] */ BSTR bstr,
/* [in] */ DWORD grfdex)
{
_RD(static char *me = "CSWbemServices::DeleteMemberByName()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.DeleteMemberByName(bstr, grfdex);
}
HRESULT STDMETHODCALLTYPE CSWbemServices::DeleteMemberByDispID(
/* [in] */ DISPID id)
{
_RD(static char *me = "CSWbemServices::DeletememberByDispId()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.DeleteMemberByDispID(id);
}
HRESULT STDMETHODCALLTYPE CSWbemServices::GetMemberProperties(
/* [in] */ DISPID id,
/* [in] */ DWORD grfdexFetch,
/* [out] */ DWORD __RPC_FAR *pgrfdex)
{
_RD(static char *me = "CSWbemServices::GetMemberProperties()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetMemberProperties(id, grfdexFetch, pgrfdex);
}
HRESULT STDMETHODCALLTYPE CSWbemServices::GetMemberName(
/* [in] */ DISPID id,
/* [out] */ BSTR __RPC_FAR *pbstrName)
{
_RD(static char *me = "CSWbemServices::GetMemberName()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetMemberName(id, pbstrName);
}
/*
* I don't think this needs implementing
*/
HRESULT STDMETHODCALLTYPE CSWbemServices::GetNextDispID(
/* [in] */ DWORD grfdex,
/* [in] */ DISPID id,
/* [out] */ DISPID __RPC_FAR *pid)
{
_RD(static char *me = "CSWbemServices::GetNextDispID()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetNextDispID(grfdex, id, pid);
}
HRESULT STDMETHODCALLTYPE CSWbemServices::GetNameSpaceParent(
/* [out] */ IUnknown __RPC_FAR *__RPC_FAR *ppunk)
{
_RD(static char *me = "CSWbemServices::GetNamespaceParent()";)
_RPrint(me, "Called", 0, "");
return m_Dispatch.GetNameSpaceParent(ppunk);
}
//***************************************************************************
// HRESULT CSWbemServices::InterfaceSupportsErrorInfo
//
// DESCRIPTION:
//
// Standard Com ISupportErrorInfo functions.
//
//***************************************************************************
STDMETHODIMP CSWbemServices::InterfaceSupportsErrorInfo (IN REFIID riid)
{
return ((IID_ISWbemServices == riid) ||
(IID_ISWbemServicesEx == riid)) ? S_OK : S_FALSE;
}
//***************************************************************************
//
// SCODE CSWbemServices::Get
//
// DESCRIPTION:
//
// Get an instance or class from a namespace
//
// PARAMETERS:
//
// bsObjectPath Relative object path to class or instance
// lFlags Flags
// pContext If specified, additional context
// ppObject On successful return addresses an
// ISWbemObject
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::Get (
BSTR objectPath,
long lFlags,
/*ISWbemNamedValueSet*/ IDispatch *pContext,
ISWbemObject **ppObject
)
{
_RD(static char *me = "CSWbemServices::Get";)
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (NULL == ppObject)
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IWbemClassObject *pIWbemClassObject = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
_RPrint(me, "Called - context: ", (long)pIContext, "");
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->GetObject (
(objectPath && (0 < wcslen(objectPath))) ? objectPath : NULL,
lFlags,
pIContext,
&pIWbemClassObject,
NULL);
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
if (SUCCEEDED(hr))
{
// Create a new CSWbemObject using the IWbemClassObject interface
// just returned.
CSWbemObject *pObject = new CSWbemObject (this, pIWbemClassObject);
if (!pObject)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pObject->QueryInterface (IID_ISWbemObject,
(PPVOID) ppObject)))
delete pObject;
pIWbemClassObject->Release ();
}
SetWbemError (this);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::Delete
//
// DESCRIPTION:
//
// Delete an instance or class from a namespace
//
// PARAMETERS:
//
// bsObjectPath Relative path of class or instance
// pKeyValue Single key value
// lFlags Flags
// pContext Any context info
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::Delete (
BSTR bsObjectPath,
long lFlags,
/*ISWbemValueBag*/ IDispatch *pContext
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (m_SecurityInfo)
{
CWbemPathCracker pathCracker (bsObjectPath);
if ((CWbemPathCracker::WbemPathType::wbemPathTypeError != pathCracker.GetType ()) &&
pathCracker.IsClassOrInstance ())
{
CComPtr<IWbemServices> pIWbemServices = GetIWbemServices ();
if (pIWbemServices)
{
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
{
if (pathCracker.IsInstance ())
hr = pIWbemServices->DeleteInstance (bsObjectPath, lFlags, pIContext, NULL);
else
hr = pIWbemServices->DeleteClass (bsObjectPath, lFlags, pIContext, NULL);
}
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
SetWbemError (this);
if (pIContext)
pIContext->Release ();
}
}
else
hr = WBEM_E_INVALID_PARAMETER;
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::InstancesOf
//
// DESCRIPTION:
//
// Create an enumerator for instances
//
// PARAMETERS:
//
// bsClass Underlying class basis for enumeration
// lFlags Flags
// pContext Any context info
// ppEnum On successful return holds the enumerator
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::InstancesOf (
BSTR bsClass,
long lFlags,
/*ISWbemValueBag*/ IDispatch *pContext,
ISWbemObjectSet **ppEnum
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (NULL == ppEnum)
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IEnumWbemClassObject *pIEnum = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->CreateInstanceEnum (bsClass, lFlags, pIContext, &pIEnum);
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
if (SUCCEEDED(hr))
{
CSWbemObjectSet *pEnum = new CSWbemObjectSet (this, pIEnum);
if (!pEnum)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pEnum->QueryInterface (IID_ISWbemObjectSet, (PPVOID) ppEnum)))
delete pEnum;
pIEnum->Release ();
}
SetWbemError (this);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::ExecQuery
//
// DESCRIPTION:
//
// Execute a query
//
// PARAMETERS:
//
// bsQuery The query strimg
// bsQueryLanguage The query language descriptor (e.g."WQL")
// lFlags Flags
// pContext Any context information
// ppEnum Returns the enumerator
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::ExecQuery (
BSTR bsQuery,
BSTR bsQueryLanguage,
long lFlags,
/*ISWbemValueBag*/ IDispatch *pContext,
ISWbemObjectSet **ppEnum)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
#ifdef __RTEST_RPC_FAILURE
extern int __Rx;
extern bool __Rdone;
__Rx = 0;
__Rdone = false;
#endif
if (NULL == ppEnum)
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IEnumWbemClassObject *pIEnum = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
/*
* We OR in the WBEM_FLAG_ENSURE_LOCATABLE flag to
* guarantee that the returned objects have the __RELPATH
* property included. This is in case anyone calls a
* method subsequently on such an object, as the "."
* notation requires that the __RELPATH property be present.
*/
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->ExecQuery
(bsQueryLanguage, bsQuery,
lFlags | WBEM_FLAG_ENSURE_LOCATABLE,
pIContext,
&pIEnum);
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
if (SUCCEEDED(hr))
{
CSWbemObjectSet *pEnum = new CSWbemObjectSet (this, pIEnum);
if (!pEnum)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pEnum->QueryInterface (IID_ISWbemObjectSet, (PPVOID) ppEnum)))
delete pEnum;
pIEnum->Release ();
}
SetWbemError (this);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::AssociatorsOf
//
// DESCRIPTION:
//
// Return the associators of a class or instance
//
// PARAMETERS:
//
// bsQuery The query strimg
// bsQueryLanguage The query language descriptor (e.g."WQL")
// lFlags Flags
// pContext Any context information
// ppEnum Returns the enumerator
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::AssociatorsOf (
BSTR strObjectPath,
BSTR strAssocClass,
BSTR strResultClass,
BSTR strResultRole,
BSTR strRole,
VARIANT_BOOL bClassesOnly,
VARIANT_BOOL bSchemaOnly,
BSTR strRequiredAssocQualifier,
BSTR strRequiredQualifier,
long lFlags,
/*ISWbemNamedValueSet*/ IDispatch *pContext,
ISWbemObjectSet **ppEnum
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if ((NULL == ppEnum) || (NULL == strObjectPath))
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IEnumWbemClassObject *pIEnum = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
// Format the query string
BSTR bsQueryLanguage = SysAllocString (OLESTR("WQL"));
BSTR bsQuery = FormatAssociatorsQuery (strObjectPath, strAssocClass, strResultClass, strResultRole,
strRole, bClassesOnly, bSchemaOnly, strRequiredAssocQualifier, strRequiredQualifier);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
/*
* We OR in the WBEM_FLAG_ENSURE_LOCATABLE flag to
* guarantee that the returned objects have the __RELPATH
* property included. This is in case anyone calls a
* method subsequently on such an object, as the "."
* notation requires that the __RELPATH property be present.
*/
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->ExecQuery
(bsQueryLanguage, bsQuery,
lFlags | WBEM_FLAG_ENSURE_LOCATABLE,
pIContext,
&pIEnum);
// Restore original privileges on this thread
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
if (SUCCEEDED(hr))
{
CSWbemObjectSet *pEnum = new CSWbemObjectSet (this, pIEnum);
if (!pEnum)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pEnum->QueryInterface (IID_ISWbemObjectSet, (PPVOID) ppEnum)))
delete pEnum;
pIEnum->Release ();
}
SetWbemError (this);
SysFreeString (bsQuery);
SysFreeString (bsQueryLanguage);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::ReferencesTo
//
// DESCRIPTION:
//
// Return the references to a class or instance
//
// PARAMETERS:
//
// bsQuery The query strimg
// bsQueryLanguage The query language descriptor (e.g."WQL")
// lFlags Flags
// pContext Any context information
// ppEnum Returns the enumerator
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::ReferencesTo (
BSTR strObjectPath,
BSTR strResultClass,
BSTR strRole,
VARIANT_BOOL bClassesOnly,
VARIANT_BOOL bSchemaOnly,
BSTR strRequiredQualifier,
long lFlags,
/*ISWbemNamedValueSet*/ IDispatch *pContext,
ISWbemObjectSet **ppEnum
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if ((NULL == ppEnum) || (NULL == strObjectPath))
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IEnumWbemClassObject *pIEnum = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
// Format the query string
BSTR bsQueryLanguage = SysAllocString (OLESTR("WQL"));
BSTR bsQuery = FormatReferencesQuery (strObjectPath, strResultClass, strRole,
bClassesOnly, bSchemaOnly, strRequiredQualifier);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
/*
* We OR in the WBEM_FLAG_ENSURE_LOCATABLE flag to
* guarantee that the returned objects have the __RELPATH
* property included. This is in case anyone calls a
* method subsequently on such an object, as the "."
* notation requires that the __RELPATH property be present.
*/
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->ExecQuery
(bsQueryLanguage, bsQuery,
lFlags | WBEM_FLAG_ENSURE_LOCATABLE,
pIContext,
&pIEnum);
// Restore original privileges on this thread
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
if (SUCCEEDED(hr))
{
CSWbemObjectSet *pEnum = new CSWbemObjectSet (this, pIEnum);
if (!pEnum)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pEnum->QueryInterface (IID_ISWbemObjectSet, (PPVOID) ppEnum)))
delete pEnum;
pIEnum->Release ();
}
SetWbemError (this);
SysFreeString (bsQuery);
SysFreeString (bsQueryLanguage);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::ExecNotificationQuery
//
// DESCRIPTION:
//
// Execute a notification query
//
// PARAMETERS:
//
// bsQuery The query strimg
// bsQueryLanguage The query language descriptor (e.g."WQL")
// lFlags Flags
// pContext Any context information
// ppEvents Returns the events iterator
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::ExecNotificationQuery (
BSTR bsQuery,
BSTR bsQueryLanguage,
long lFlags,
/*ISWbemValueBag*/ IDispatch *pContext,
ISWbemEventSource **ppEvents)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (NULL == ppEvents)
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IEnumWbemClassObject *pIEnum = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->ExecNotificationQuery
(bsQueryLanguage, bsQuery, lFlags, pIContext, &pIEnum);
if (SUCCEEDED(hr))
{
CSWbemEventSource *pEvents = new CSWbemEventSource (this, pIEnum);
if (!pEvents)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pEvents->QueryInterface (IID_ISWbemEventSource, (PPVOID) ppEvents)))
delete pEvents;
pIEnum->Release ();
}
// Restore original privileges on this thread
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
SetWbemError (this);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::ExecMethod
//
// DESCRIPTION:
//
// Execute a method
//
// PARAMETERS:
//
// bsObjectPath Relative path to object
// bsMethod The name of the method to call
// pInParams The in-parameters
// lFlags Flags
// pContext Any context information
// ppOutParams The out-parameters
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::ExecMethod (
BSTR bsObjectPath,
BSTR bsMethod,
/*ISWbemObject*/ IDispatch *pInParams,
long lFlags,
/*ISWbemValueBag*/ IDispatch *pContext,
ISWbemObject **ppOutParams
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IWbemClassObject *pIInParams = CSWbemObject::GetIWbemClassObject (pInParams);
IWbemClassObject *pIOutParams = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->ExecMethod
(bsObjectPath, bsMethod, lFlags, pIContext, pIInParams, &pIOutParams, NULL);
if (SUCCEEDED(hr))
{
if (pIOutParams)
{
if (ppOutParams)
{
CSWbemObject *pObject = new CSWbemObject (this, pIOutParams);
if (!pObject)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pObject->QueryInterface (IID_ISWbemObject,
(PPVOID) ppOutParams)))
delete pObject;
}
pIOutParams->Release ();
}
}
// Restore original privileges on this thread
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
SetWbemError (this);
if (pIContext)
pIContext->Release ();
if (pIInParams)
pIInParams->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::SubclassesOf
//
// DESCRIPTION:
//
// Create an enumerator for classes
//
// PARAMETERS:
//
// bsSuperClass Underlying class basis for enumeration
// lFlags Flags
// pContext Any context info
// ppEnum On successful return holds the enumerator
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::SubclassesOf (
BSTR bsSuperClass,
long lFlags,
/*ISWbemValueBag*/ IDispatch *pContext,
ISWbemObjectSet **ppEnum
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (NULL == ppEnum)
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IEnumWbemClassObject *pIEnum = NULL;
// Get the context
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
hr = pIWbemServices->CreateClassEnum
(bsSuperClass, lFlags, pIContext, &pIEnum);
if (SUCCEEDED(hr))
{
CSWbemObjectSet *pEnum = new CSWbemObjectSet (this, pIEnum);
if (!pEnum)
hr = WBEM_E_OUT_OF_MEMORY;
else if (FAILED(hr = pEnum->QueryInterface (IID_ISWbemObjectSet, (PPVOID) ppEnum)))
delete pEnum;
pIEnum->Release ();
}
// Restore original privileges on this thread
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
SetWbemError (this);
if (pIContext)
pIContext->Release ();
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::get_Security_
//
// DESCRIPTION:
//
// Return the security configurator
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::get_Security_ (
ISWbemSecurity **ppSecurity
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (NULL == ppSecurity)
hr = WBEM_E_INVALID_PARAMETER;
{
*ppSecurity = NULL;
if (m_SecurityInfo)
{
*ppSecurity = m_SecurityInfo;
(*ppSecurity)->AddRef ();
hr = WBEM_S_NO_ERROR;
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// SCODE CSWbemServices::Put
//
// DESCRIPTION:
//
// Save/commit a class or instance into this namespace
//
// PARAMETERS:
//
// objWbemObject Class/Instance to be saved
// lFlags Flags
// pContext Context
// ppObjectPath Object Path
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
//***************************************************************************
HRESULT CSWbemServices::Put (
ISWbemObjectEx *objWbemObject,
long lFlags,
/*ISWbemNamedValueSet*/ IDispatch *pContext,
ISWbemObjectPath **ppObjectPath
)
{
HRESULT hr = WBEM_E_FAILED;
ResetLastErrors ();
if (NULL == objWbemObject)
hr = WBEM_E_INVALID_PARAMETER;
else if (m_SecurityInfo)
{
IWbemServices *pIWbemServices = (IWbemServices *) m_SecurityInfo->GetProxy ();
if (pIWbemServices)
{
IWbemClassObject *pObject = CSWbemObject::GetIWbemClassObject (objWbemObject);
IWbemContext *pIContext = CSWbemNamedValueSet::GetIWbemContext (pContext, m_pIServiceProvider);
if (NULL != pObject)
{
// Figure out whether this is a class or instance
VARIANT var;
VariantInit (&var);
if (WBEM_S_NO_ERROR == pObject->Get (WBEMS_SP_GENUS, 0, &var, NULL, NULL))
{
IWbemCallResult *pResult = NULL;
HRESULT hrCallResult = WBEM_E_FAILED;
bool needToResetSecurity = false;
HANDLE hThreadToken = NULL;
if (m_SecurityInfo->SetSecurity (needToResetSecurity, hThreadToken))
{
if (WBEM_GENUS_CLASS == var.lVal)
hrCallResult = pIWbemServices->PutClass
(pObject, lFlags | WBEM_FLAG_RETURN_IMMEDIATELY, pIContext, &pResult);
else
hrCallResult = pIWbemServices->PutInstance
(pObject, lFlags | WBEM_FLAG_RETURN_IMMEDIATELY, pIContext, &pResult);
if (needToResetSecurity)
m_SecurityInfo->ResetSecurity (hThreadToken);
}
if (WBEM_S_NO_ERROR == hrCallResult)
{
//Secure the IWbemCallResult interface
m_SecurityInfo->SecureInterface (pResult);
if ((WBEM_S_NO_ERROR == (hrCallResult = pResult->GetCallStatus (INFINITE, &hr))) &&
(WBEM_S_NO_ERROR == hr))
{
if (ppObjectPath)
{
ISWbemObjectPath *pObjectPath = new CSWbemObjectPath (m_SecurityInfo, GetLocale());
if (!pObjectPath)
hr = WBEM_E_OUT_OF_MEMORY;
else
{
pObjectPath->AddRef ();
pObjectPath->put_Path (GetPath ());
if (WBEM_GENUS_CLASS == var.lVal)
{
VARIANT nameVar;
VariantInit (&nameVar);
/*
* 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 ((WBEM_S_NO_ERROR == pObject->Get (WBEMS_SP_CLASS, 0, &nameVar, NULL, NULL))
&& (VT_BSTR == V_VT(&nameVar)))
{
pObjectPath->put_Class (nameVar.bstrVal);
*ppObjectPath = pObjectPath;
}
VariantClear (&nameVar);
}
else
{
// Now get the relpath string from the call result
BSTR resultString = NULL;
if (WBEM_S_NO_ERROR == pResult->GetResultString (INFINITE, &resultString))
{
pObjectPath->put_RelPath (resultString);
*ppObjectPath = pObjectPath;
SysFreeString (resultString);
}
}
}
}
}
}
else
hr = hrCallResult;
if (pResult)
pResult->Release ();
}
if (pIContext)
pIContext->Release ();
pObject->Release ();
VariantClear (&var);
}
SetWbemError (this);
pIWbemServices->Release ();
}
}
if (FAILED(hr))
m_Dispatch.RaiseException (hr);
return hr;
}
//***************************************************************************
//
// CSWbemServices::GetIWbemServices
//
// DESCRIPTION:
//
// Return the IWbemServices interface corresponding to this
// scriptable wrapper.
//
// PARAMETERS:
// ppServices holds the IWbemServices pointer on return
//
// RETURN VALUES:
// S_OK success
// E_FAIL otherwise
//
// NOTES:
// If successful, the returned interface is AddRef'd; the caller is
// responsible for release.
//
//***************************************************************************
STDMETHODIMP CSWbemServices::GetIWbemServices (IWbemServices **ppServices)
{
HRESULT hr = E_FAIL;
if (ppServices)
{
*ppServices = GetIWbemServices ();
hr = S_OK;
}
return hr;
}
//***************************************************************************
//
// CSWbemServices::GetIWbemServices
//
// DESCRIPTION:
//
// Given an IDispatch interface which we hope is also an ISWbemServicesEx
// interface, return the underlying IWbemServices interface.
//
// PARAMETERS:
// pDispatch the IDispatch in question
//
// RETURN VALUES:
// The underlying IWbemServices interface, or NULL.
//
// NOTES:
// If successful, the returned interface is AddRef'd; the caller is
// responsible for release.
//
//***************************************************************************
IWbemServices *CSWbemServices::GetIWbemServices (
IDispatch *pDispatch
)
{
IWbemServices *pServices = NULL;
ISWbemInternalServices *pIServices = NULL;
if (pDispatch)
{
if (SUCCEEDED (pDispatch->QueryInterface
(IID_ISWbemInternalServices, (PPVOID) &pIServices)))
{
pIServices->GetIWbemServices (&pServices);
pIServices->Release ();
}
}
return pServices;
}
Reference in a new issue Copy permalink