//***************************************************************************
//
//  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;
}