dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/xmltransport/server/wmixmlop/wmixmlt.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

2843 lines
90 KiB
C++
Raw Permalink Blame History

//***************************************************************************
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// PARSE.CPP
//
// rajeshr 3/25/2000 Created.
//
// Contains the class that interacts with WMI to satisfy XML/HTTP requests
//
//***************************************************************************
#include <windows.h>
#include <stdio.h>
#include <initguid.h>
#include <objbase.h>
#include <wbemcli.h>
#include <wmiutils.h>
#include <genlex.h>
#include <opathlex.h>
#include <objpath.h>
#include <cominit.h>
#include <httpext.h>
#include <msxml.h>
#include "provtempl.h"
#include "common.h"
#include "wmixmlop.h"
#include "wmixmlst.h"
#include "concache.h"
#include "wmiconv.h"
#include "xml2wmi.h"
#include "wmixmlt.h"
#include "request.h"
#include "whistler.h"
#include "strings.h"
#include "xmlhelp.h"
#include "parse.h"
// Strings for queries
#define WMIXMLT_Q L"select __CLASS,__GENUS,__SUPERCLASS, __PATH, __RELPATH, "
static WCHAR *BuildPropertyList (DWORD dwNumProperties, BSTR *pPropertyArray);
static BSTR FormatAssociatorsQuery(
BSTR strObjectPath,
BSTR strAssocClass,
BSTR strResultClass,
BSTR strResultRole,
BSTR strRole,
VARIANT_BOOL bClassesOnly,
VARIANT_BOOL bSchemaOnly,
BSTR strRequiredAssocQualifier,
BSTR strRequiredQualifier
);
static BSTR FormatReferencesQuery(
BSTR strObjectPath,
BSTR strResultClass,
BSTR strRole,
VARIANT_BOOL bClassesOnly,
VARIANT_BOOL bSchemaOnly,
BSTR strRequiredQualifier
);
// Required for the Query parser
static ULONG uFeatures[] =
{
WMIQ_LF1_BASIC_SELECT,
WMIQ_LF2_CLASS_NAME_IN_QUERY
};
// Strings for association and reference queries
#define WMIXML_QUERY_ASSOCOF OLESTR("associators of ")
#define WMIXML_QUERY_OPENBRACE OLESTR("{")
#define WMIXML_QUERY_CLOSEBRACE OLESTR("}")
#define WMIXML_QUERY_WHERE OLESTR(" where ")
#define WMIXML_QUERY_ASSOCCLASS OLESTR(" AssocClass ")
#define WMIXML_QUERY_EQUALS OLESTR("=")
#define WMIXML_QUERY_CLASSDEFS OLESTR(" ClassDefsOnly ")
#define WMIXML_QUERY_REQASSOCQ OLESTR(" RequiredAssocQualifier ")
#define WMIXML_QUERY_REQQUAL OLESTR(" RequiredQualifier ")
#define WMIXML_QUERY_RESCLASS OLESTR(" ResultClass ")
#define WMIXML_QUERY_RESROLE OLESTR(" ResultRole ")
#define WMIXML_QUERY_ROLE OLESTR(" Role ")
#define WMIXML_QUERY_SCHEMAONLY OLESTR(" SchemaOnly ")
#define WMIXML_QUERY_REFOF OLESTR("references of ")
//***************************************************************************
//
// CXMLTranslator::CXMLTranslator
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CXMLTranslator::CXMLTranslator(IXMLDOMNode *pContext, WMI_XML_HTTP_VERSION iHttpVersion, IStream *pPrefixStream, IStream *pSuffixStream)
{
m_iHttpVersion = iHttpVersion;
if(m_pContext = pContext)
m_pContext->AddRef();
if(m_pPrefixStream = pPrefixStream)
m_pPrefixStream->AddRef();
if(m_pSuffixStream = pSuffixStream)
m_pSuffixStream->AddRef();
}
//***************************************************************************
//
// CXMLTranslator::~CXMLTranslator
//
// DESCRIPTION:
//
// Destructor.
//
//***************************************************************************
CXMLTranslator::~CXMLTranslator(void)
{
if(m_pPrefixStream)
m_pPrefixStream->Release();
if(m_pSuffixStream)
m_pSuffixStream->Release();
if(m_pContext)
m_pContext->Release();
}
//***************************************************************************
//
// SCODE CXMLTranslator::GetObject
//
// DESCRIPTION:
//
// Transforms a single WBEM object into its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pszObjectPath The relative (model) path of the object within
// that namespace
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::GetObject (
BSTR pszNamespacePath,
BSTR pszObjectPath,
DWORD dwNumProperties,
BSTR *pPropertyArray,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if (NULL == pszObjectPath)
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Get the requested object
IWbemClassObject *pObject = NULL;
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
if(WBEM_E_INVALID_PARAMETER == (hr = pService->GetObject (pszObjectPath, WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pObject, NULL)))
hr = pService->GetObject (pszObjectPath, 0, pContext, &pObject, NULL);
if (WBEM_S_NO_ERROR == hr)
{
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// Now do the translation
if(SUCCEEDED(hr = SetI4ContextValue(pFlagsContext, L"PathLevel", 0)))
{
// Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
pConvertor->MapObjectToXML(pObject, pPropertyArray, dwNumProperties, pFlagsContext, m_pPrefixStream, NULL);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
pConvertor->Release();
}
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
// The reason we create a new stream instead of writing into m_pPrefixStream
// is that we dont know if the call to MapObjectToXML will be successful
// In the case it isnt, then we cannot write the IRETURNVALUE tag
// In the case it is, we need to write the IRETURNVALUE tag before
// the encoding of the object
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// Now do the translation
if(SUCCEEDED(hr = SetI4ContextValue(pFlagsContext, L"PathLevel", 0)))
{
if (SUCCEEDED(hr = pConvertor->MapObjectToXML(pObject, pPropertyArray, dwNumProperties, pFlagsContext, pStream, NULL)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1);
}
}
pConvertor->Release();
}
pStream->Release ();
}
}
break;
}
pObject->Release ();
}
}
// Release the IWbemContext, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::GetProperty
//
// DESCRIPTION:
//
// Transforms a single WBEM Property value into its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pszObjectPath The relative (model) path of the object within
// that namespace
// pszPropertyName Name of the property whose value is requested
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::GetProperty (
BSTR pszNamespacePath,
BSTR pszObjectPath,
BSTR pszPropertyName,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszObjectPath) || (NULL == pszPropertyName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Dont create a new context if we already have one
if(pContext || (!pContext && SUCCEEDED(hr = CoCreateInstance (CLSID_WbemContext, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemContext, (void**) &pContext))) )
{
// Add the per-property GET information into the context
VARIANT var;
VariantInit (&var);
var.vt = VT_BOOL;
var.boolVal = VARIANT_TRUE;
HRESULT hr2 = pContext->SetValue (L"__GET_EXTENSIONS", 0, &var);
VariantClear (&var);
SAFEARRAYBOUND rgsabound [1];
rgsabound [0].lLbound = 0;
rgsabound [0].cElements = 1;
SAFEARRAY *pArray = SafeArrayCreate (VT_BSTR, 1, rgsabound);
long ix = 0;
hr2 = SafeArrayPutElement (pArray, &ix, pszPropertyName);
var.vt = VT_ARRAY|VT_BSTR;
var.parray = pArray;
hr2 = pContext->SetValue (L"__GET_EXT_PROPERTIES", 0, &var);
VariantClear (&var);
// Get the requested object
IWbemClassObject *pObject = NULL;
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
if(WBEM_E_INVALID_PARAMETER == (hr = pService->GetObject (pszObjectPath, WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pObject, NULL)))
hr = pService->GetObject (pszObjectPath, 0, pContext, &pObject, NULL);
if (WBEM_S_NO_ERROR == hr)
{
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
hr = pConvertor->MapPropertyToXML (pObject, pszPropertyName, pFlagsContext, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
pConvertor->Release();
}
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// Now do the translation
if (SUCCEEDED(hr = pConvertor->MapPropertyToXML (pObject, pszPropertyName, pFlagsContext, pStream)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1);
}
pConvertor->Release();
}
pStream->Release ();
}
}
break;
}
pObject->Release ();
}
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::SetProperty
//
// DESCRIPTION:
//
// Updates a single WBEM Property value
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pszObjectPath The relative (model) path of the object within
// that namespace
// pszPropertyName Name of the property whose value is requested
// pszPropertyValue The proposed value as an XML string
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::SetProperty (
BSTR pszNamespacePath,
BSTR pszObjectPath,
BSTR pszPropertyName,
IXMLDOMNode *pPropertyValue,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszObjectPath) || (NULL == pszPropertyName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Get the requested object first
IWbemClassObject *pObject = NULL;
if (WBEM_S_NO_ERROR == (hr = pService->GetObject (pszObjectPath, 0, NULL, &pObject, NULL)))
{
// Map the property value to its VARIANT equivalent and set in the
// object
VARIANT vvar;
VariantInit (&vvar);
CIMTYPE cimtype;
long flavor;
if (SUCCEEDED (hr = pObject->Get (pszPropertyName, 0, &vvar, &cimtype, &flavor)))
{
// Got the property - now map the new value and attempt to set it
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(pPropertyValue)))
{
if (SUCCEEDED (hr = xmlToWmi.MapPropertyValue (vvar, cimtype)))
{
if (SUCCEEDED (hr = pObject->Put (pszPropertyName, 0, &vvar, 0)))
{
// Set the value OK - now do a per-property put to commit the change
if (pContext || (!pContext && SUCCEEDED(hr = CoCreateInstance (CLSID_WbemContext, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemContext, (void**) &pContext))) )
{
// Add the per-property PUT information into the context
VARIANT cvar;
VariantInit (&cvar);
cvar.vt = VT_BOOL;
cvar.boolVal = VARIANT_TRUE;
HRESULT hr2 = pContext->SetValue (L"__PUT_EXTENSIONS", 0, &cvar);
VariantClear (&cvar);
SAFEARRAYBOUND rgsabound [1];
rgsabound [0].lLbound = 0;
rgsabound [0].cElements = 1;
SAFEARRAY *pArray = SafeArrayCreate (VT_BSTR, 1, rgsabound);
long ix = 0;
hr2 = SafeArrayPutElement (pArray, &ix, pszPropertyName);
cvar.vt = VT_ARRAY|VT_BSTR;
cvar.parray = pArray;
hr2 = pContext->SetValue (L"__PUT_EXT_PROPERTIES", 0, &cvar);
VariantClear (&cvar);
// Set the instance - if we get WBEM_E_PROVIDER_NOT_CAPABLE,
// roll back to a simple put with no context
hr = pService->PutInstance (pObject, WBEM_FLAG_UPDATE_ONLY,
pContext, NULL);
if (WBEM_E_PROVIDER_NOT_CAPABLE == hr)
hr = pService->PutInstance (pObject, WBEM_FLAG_UPDATE_ONLY,
NULL, NULL);
}
}
}
}
}
VariantClear (&vvar);
pObject->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::CreateClass
//
// DESCRIPTION:
//
// Creates a new WMI class or modifies an existing one
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pClass The new class definition in XML format
// bIsModify Whether this is a modify operation
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::CreateClass (
BSTR pszNamespacePath,
IXMLDOMNode *pClass,
BOOL bIsModify,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext,
LONG lFlags)
{
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pClass))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
if (!bIsModify)
{
// Get the base object first; need to know if this is derived or not
IWbemClassObject *pObject = NULL;
// Should have a CLASS element - does it have a SUPERCLASS attribute?
BSTR strSuperClass = NULL;
GetBstrAttribute (pClass, SUPERCLASS_ATTRIBUTE, &strSuperClass);
if (WBEM_S_NO_ERROR == (hr = pService->GetObject (strSuperClass, 0, pContext, &pObject, NULL)))
{
// Got the underlying class - now map the new value and attempt to set it
if (strSuperClass && (0 < wcslen (strSuperClass)))
{
IWbemClassObject *pSubClass = NULL;
if (SUCCEEDED(hr = pObject->SpawnDerivedClass (0, &pSubClass)))
{
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(pClass, pService, pSubClass)))
{
if (SUCCEEDED (hr = xmlToWmi.MapClass ()))
hr = pService->PutClass (pSubClass, WBEM_FLAG_CREATE_OR_UPDATE | lFlags, pContext, NULL);
}
pSubClass->Release ();
}
}
else
{
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(pClass, pService, pObject)))
{
if (SUCCEEDED(hr = xmlToWmi.MapClass ()))
hr = pService->PutClass (pObject, WBEM_FLAG_CREATE_OR_UPDATE|lFlags, pContext, NULL);
}
}
pObject->Release ();
}
SysFreeString (strSuperClass);
}
else
{
// Get the existing class definition first
IWbemClassObject *pObject = NULL;
// Should have a CLASS element - does it have a NAME attribute?
BSTR strClass = NULL;
GetBstrAttribute (pClass, NAME_ATTRIBUTE, &strClass);
if (WBEM_S_NO_ERROR == (hr = pService->GetObject (strClass, 0, pContext, &pObject, NULL)))
{
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(pClass, pService, pObject)))
{
if (SUCCEEDED(hr = xmlToWmi.MapClass (TRUE)))
hr = pService->PutClass (pObject, WBEM_FLAG_UPDATE_ONLY|lFlags, NULL, NULL);
}
pObject->Release ();
}
SysFreeString (strClass);
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::CreateInstance
//
// DESCRIPTION:
//
// Creates a new WMI instance
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pInstance The new instance definition in XML format
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::CreateInstance (
BSTR pszNamespacePath,
IXMLDOMNode *pInstance,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext,
LONG lFlags)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pInstance))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
IWbemClassObject *pObject = NULL;
// Should have a CLASSNAME attribute
BSTR strClassName = NULL;
GetBstrAttribute (pInstance, CLASS_NAME_ATTRIBUTE, &strClassName);
if (strClassName && (0 < wcslen (strClassName)) &&
WBEM_S_NO_ERROR == (hr = pService->GetObject (strClassName, 0, NULL, &pObject, NULL)))
{
// Got the underlying class - now map the new value and attempt to set it
IWbemClassObject *pNewInstance = NULL;
if (SUCCEEDED(hr = pObject->SpawnInstance (0, &pNewInstance)))
{
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(pInstance, pService, pNewInstance)))
{
if (SUCCEEDED (hr = xmlToWmi.MapInstance ()))
{
IWbemCallResult *pResult = NULL;
// We need to make this a semi-sync call so that we can get
// the object name of the create object
if (SUCCEEDED(hr = pService->PutInstance
(pNewInstance, WBEM_FLAG_CREATE_ONLY|WBEM_FLAG_RETURN_IMMEDIATELY|lFlags, pContext, &pResult)) && pResult)
{
HRESULT hCallResult = S_OK;
if (SUCCEEDED(hr = pResult->GetCallStatus (INFINITE, &hCallResult)))
{
if(SUCCEEDED(hCallResult))
{
// Now get the relpath string from the call result
hr = WBEM_E_FAILED;
BSTR resultString = NULL;
if (SUCCEEDED(hr = pResult->GetResultString (INFINITE, &resultString)))
{
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
hr = pConvertor->MapInstanceNameToXML(resultString, pFlagsContext, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
pConvertor->Release();
}
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// Now do the translation
if (SUCCEEDED(hr = pConvertor->MapInstanceNameToXML(resultString, pFlagsContext, pStream)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1);
}
pConvertor->Release();
}
pStream->Release ();
}
}
break;
}
SysFreeString (resultString);
}
}
else
hr = hCallResult;
}
pResult->Release ();
}
}
}
pNewInstance->Release ();
}
pObject->Release ();
}
SysFreeString (strClassName);
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::ModifyInstance
//
// DESCRIPTION:
//
// Modifies an existing WMI instance
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pInstance The new instance definition in XML format
// pszInstancePath The instance path
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::ModifyInstance (
BSTR pszNamespacePath,
IXMLDOMNode *pInstance,
BSTR pszInstancePath,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext,
LONG lFlags
)
{
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszInstancePath) || (NULL == pszNamespacePath) || (NULL == pInstance))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
IWbemClassObject *pCurInstance = NULL;
// Get the instance (MUST exist)
if (WBEM_S_NO_ERROR == (hr = pService->GetObject (pszInstancePath, 0, NULL, &pCurInstance, NULL)))
{
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(pInstance, pService, pCurInstance)))
{
if (SUCCEEDED (hr = xmlToWmi.MapInstance (TRUE)))
hr = pService->PutInstance (pCurInstance, WBEM_FLAG_UPDATE_ONLY|lFlags, pContext, NULL);
}
pCurInstance->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::DeleteObject
//
// DESCRIPTION:
//
// Delete a class or instance
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides
// pszObjectPath The relative (model) path of the object within
// that namespace
// bIsClass Whether this is a class or instance
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::DeleteObject (
BSTR pszNamespacePath,
BSTR pszObjectPath,
BOOL bIsClass,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
HRESULT hr = WBEM_E_FAILED;
if (NULL == pszObjectPath)
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Delete the requested object
hr = (bIsClass) ? pService->DeleteClass (pszObjectPath, 0, pContext, NULL):
pService->DeleteInstance (pszObjectPath, 0, pContext, NULL);
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::ExecuteQuery
//
// DESCRIPTION:
//
// Transforms the query result set nto its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszQueryLanguage The query language used
// pszQueryString The query to execute within that namespace.
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::ExecuteQuery (
BSTR pszNamespacePath,
BSTR pszQueryLanguage,
BSTR pszQueryString,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszQueryString))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Transform the query to include suitable system properties
BOOL bMustFreeQueryString = TransformQuery (&pszQueryString);
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
long lFlags = WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
if(WBEM_E_INVALID_PARAMETER == (hr = pService->ExecQuery (pszQueryLanguage, pszQueryString, lFlags | WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pEnum)))
hr = pService->ExecQuery (pszQueryLanguage, pszQueryString, lFlags, pContext, &pEnum);
if (WBEM_S_NO_ERROR == hr)
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
MapEnum (pEnum, 3, 0, NULL, NULL, pECB, pFlagsContext, FALSE, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
SaveStreamToIISSocket(m_pPrefixStream, pECB, TRUE);
WRITEBSTR(m_pSuffixStream, L"</IRETURNVALUE>");
// Create VALUE.OBJECTs
MapEnum (pEnum, 0, 0, NULL, NULL, pECB, pFlagsContext, TRUE);
}
break;
}
pEnum->Release ();
}
if (bMustFreeQueryString)
SysFreeString (pszQueryString);
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::EnumerateInstanceNames
//
// DESCRIPTION:
//
// Transforms the query result set into its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszClassName The class whose instance names are to be enumerated
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::EnumerateInstanceNames (
BSTR pszNamespacePath,
BSTR pszClassName,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszClassName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
BSTR bsQueryLang = NULL;
if(bsQueryLang = SysAllocString(L"WQL"))
{
LPWSTR pszQuery = NULL;
if(pszQuery = new WCHAR [ wcslen(L"select __RELPATH from ") + wcslen(pszClassName) + 1])
{
pszQuery[0] = NULL;
wcscat(pszQuery, L"select __RELPATH from ");
wcscat(pszQuery, pszClassName);
BSTR bsQuery = NULL;
if(bsQuery = SysAllocString(pszQuery))
{
// RAJESHR - Use semi sync and Forward only enumerator?
long lFlags = WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
if (SUCCEEDED (hr = pService->ExecQuery
(bsQueryLang, bsQuery, 0, pContext, &pEnum)))
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
MapEnumNames (m_pPrefixStream, pEnum, 2, pFlagsContext);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Now do the translation
if (SUCCEEDED(MapEnumNames (pStream, pEnum, 2, pFlagsContext)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, TRUE);
}
pStream->Release ();
}
}
break;
}
pEnum->Release ();
}
SysFreeString (bsQuery);
}
else
hr = E_OUTOFMEMORY;
delete [] pszQuery;
}
else
hr = E_OUTOFMEMORY;
SysFreeString (bsQueryLang);
}
else
hr = E_OUTOFMEMORY;
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::EnumerateClassNames
//
// DESCRIPTION:
//
// Transforms the query result set into its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszClassName The class whose subclass names are to be enumerated
// bDeepInheritance Whether to do a deep inheritance
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::EnumerateClassNames (
BSTR pszNamespacePath,
BSTR pszClassName,
BOOL bDeepInheritance,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszClassName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
LONG lFlags = (bDeepInheritance) ? WBEM_FLAG_DEEP : WBEM_FLAG_SHALLOW;
// RAJESHR - Can this be done more efficiently via a schema query ?
lFlags |= (WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY);
if (SUCCEEDED (hr = pService->CreateClassEnum
(pszClassName, lFlags, pContext, &pEnum)))
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
MapClassNames (m_pPrefixStream, pEnum, pFlagsContext);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Now do the translation
if (SUCCEEDED(hr = MapClassNames (pStream, pEnum, pFlagsContext)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, TRUE);
}
pStream->Release ();
}
}
break;
}
pEnum->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::EnumerateInstances
//
// DESCRIPTION:
//
// Transforms the query result set nto its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszClassName The class to be enumerated
// bDeep Whether this enumeration is deep
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::EnumerateInstances (
BSTR pszNamespacePath,
BSTR pszClassName,
VARIANT_BOOL bDeep,
BOOL bIsMicrosoftWMIClient,
DWORD dwNumProperties,
BSTR *pPropertyArray,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszClassName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the Enumeration - RAJESHR if a property list is specified, can we make it more efficient using a Query?
IEnumWbemClassObject *pEnum = NULL;
long lFlags = WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
// DMTF and Microsoft have different interpretations of the Deep enumeration
// For DMTF, we always have to ask our CIMOM to do a Deep enumeration and post-process
// later. Whereas, for Microsoft we directly pass the flag as it is
if(bIsMicrosoftWMIClient)
{
if(VARIANT_TRUE == bDeep) lFlags |= WBEM_FLAG_DEEP;
}
else // For DMTF
lFlags |= WBEM_FLAG_DEEP;
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
if(WBEM_E_INVALID_PARAMETER == (hr = pService->CreateInstanceEnum (pszClassName, lFlags | WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pEnum)))
hr = pService->CreateInstanceEnum (pszClassName, lFlags, pContext, &pEnum);
if (WBEM_S_NO_ERROR == hr)
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
// For Deep Enumerations and WMI Enumerations, we dont do anything special
// For shallow instance enumerations we have to give the class basis
// the CWmiToXml object so it can emulate DMTF-style shallow enumeration
if (VARIANT_TRUE == bDeep || bIsMicrosoftWMIClient)
MapEnum (pEnum, 1, dwNumProperties, pPropertyArray, NULL, pECB, pFlagsContext, FALSE, m_pPrefixStream);
else
MapEnum (pEnum, 1, dwNumProperties, pPropertyArray, pszClassName, pECB, pFlagsContext, FALSE, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
SaveStreamToIISSocket(m_pPrefixStream, pECB, TRUE);
WRITEBSTR(m_pSuffixStream, L"</IRETURNVALUE>");
// Now do the translation
// For shallow instance enumerations we have to give the class basis
// the CWmiToXml object so it can emulate DMTF-style shallow enumeration
if (VARIANT_TRUE == bDeep || bIsMicrosoftWMIClient)
MapEnum (pEnum, 1, dwNumProperties, pPropertyArray, NULL, pECB, pFlagsContext, TRUE);
else
MapEnum (pEnum, 1, dwNumProperties, pPropertyArray, pszClassName, pECB, pFlagsContext, TRUE);
}
break;
}
pEnum->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::EnumerateClasses
//
// DESCRIPTION:
//
// Transforms the query result set nto its equivalent XML representation
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszClassName The class to be enumerated
// bDeep Whether this enumeration is deep
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::EnumerateClasses (
BSTR pszNamespacePath,
BSTR pszClassName,
VARIANT_BOOL bDeep,
DWORD dwNumProperties,
BSTR *pPropertyArray,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszClassName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
long lDeepFlag = WBEM_FLAG_DEEP;
if(bDeep == VARIANT_FALSE)
lDeepFlag = WBEM_FLAG_SHALLOW;
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
lDeepFlag |= WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
if(WBEM_E_INVALID_PARAMETER == (hr = pService->CreateClassEnum (pszClassName, lDeepFlag | WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pEnum)))
hr = pService->CreateClassEnum (pszClassName, lDeepFlag, pContext, &pEnum);
if (WBEM_S_NO_ERROR == hr)
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
MapEnum (pEnum, 0, dwNumProperties, pPropertyArray, NULL, pECB, pFlagsContext, FALSE, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
SaveStreamToIISSocket(m_pPrefixStream, pECB, (m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1));
WRITEBSTR(m_pSuffixStream, L"</IRETURNVALUE>");
// Now do the translation
MapEnum (pEnum, 0, dwNumProperties, pPropertyArray, NULL, pECB, pFlagsContext, (m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1));
}
break;
}
pEnum->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::Associators
//
// DESCRIPTION:
//
// Performs an "ASSOCIATORS OF" query and transforms the result into XML
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszClassName The class to be enumerated
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::Associators (
BSTR pszNamespacePath,
BSTR pszObjectName,
BSTR pszAssocClass,
BSTR pszResultClass,
BSTR pszRole,
BSTR pszResultRole,
DWORD dwNumProperties,
BSTR *pPropertyArray,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszObjectName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
WCHAR *strPropertyList = BuildPropertyList (dwNumProperties, pPropertyArray);
BSTR bsQueryLang = NULL;
bsQueryLang = SysAllocString(L"WQL");
// Build the ASSOCIATORS OF query
BSTR bsQuery = FormatAssociatorsQuery (pszObjectName, pszAssocClass, pszResultClass,
pszResultRole, pszRole, FALSE, FALSE, NULL, NULL);
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
long lFlags = WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
if(WBEM_E_INVALID_PARAMETER == (hr = pService->ExecQuery (bsQueryLang, bsQuery, lFlags | WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pEnum)))
hr = pService->ExecQuery (bsQueryLang, bsQuery, lFlags, pContext, &pEnum);
SysFreeString (bsQueryLang);
SysFreeString (bsQuery);
if (WBEM_S_NO_ERROR == hr)
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
MapEnum (pEnum, 3, 0, NULL, NULL, pECB, pFlagsContext, FALSE, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
SaveStreamToIISSocket(m_pPrefixStream, pECB, TRUE);
WRITEBSTR(m_pSuffixStream, L"</IRETURNVALUE>");
MapEnum (pEnum, 3, 0, NULL, NULL, pECB, pFlagsContext, TRUE);
}
break;
}
pEnum->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::AssociatorNames
//
// DESCRIPTION:
//
// Performs an "ASSOCIATORS OF" query, gets the names and transforms the
/// result into XML
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszObjectName The object whose assocaitors are required
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::AssociatorNames (
BSTR pszNamespacePath,
BSTR pszObjectName,
BSTR pszAssocClass,
BSTR pszResultClass,
BSTR pszRole,
BSTR pszResultRole,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszObjectName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
BSTR bsQueryLang = NULL;
bsQueryLang = SysAllocString(L"WQL");
// Build the ASSOCIATORS OF query
BSTR bsQuery = FormatAssociatorsQuery (pszObjectName, pszAssocClass, pszResultClass,
pszResultRole, pszRole, FALSE, FALSE, NULL, NULL);
// RAJESHR - Use semi sync and Forward only enumerator?
long lFlags = WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
if(SUCCEEDED(hr = pService->ExecQuery (bsQueryLang, bsQuery, lFlags, pContext, &pEnum)))
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
MapEnumNames (m_pPrefixStream, pEnum, 3, pFlagsContext);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Now do the translation
if (SUCCEEDED(MapEnumNames (pStream, pEnum, 3, pFlagsContext)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1);
}
pStream->Release ();
}
}
break;
}
pEnum->Release ();
}
SysFreeString (bsQueryLang);
SysFreeString (bsQuery);
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::References
//
// DESCRIPTION:
//
// Performs an "REFERENCES OF" query and transforms the result into XML
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszClassName The class to be enumerated
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::References (
BSTR pszNamespacePath,
BSTR pszObjectName,
BSTR pszResultClass,
BSTR pszRole,
DWORD dwNumProperties,
BSTR *pPropertyArray,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszObjectName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
WCHAR *strPropertyList = BuildPropertyList (dwNumProperties, pPropertyArray);
BSTR bsQueryLang = SysAllocString(L"WQL");
// Build the ASSOCIATORS OF query
BSTR bsQuery = FormatReferencesQuery (pszObjectName, pszResultClass,
pszRole, FALSE, FALSE, NULL);
// Check to see if this version of WMI supports the WBEM_FLAG_USE_AMENDED_QUALIFIERS flag
// Otherwise, make a best effort call with no flags.
// We need this to get the properties that have the "amended" qualifier on them
long lFlags = WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY;
if(WBEM_E_INVALID_PARAMETER == (hr = pService->ExecQuery (bsQueryLang, bsQuery, lFlags | WBEM_FLAG_USE_AMENDED_QUALIFIERS, pContext, &pEnum)))
hr = pService->ExecQuery (bsQueryLang, bsQuery, lFlags, pContext, &pEnum);
SysFreeString (bsQueryLang);
SysFreeString (bsQuery);
if (WBEM_S_NO_ERROR == hr)
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
MapEnum (pEnum, 3, 0, NULL, NULL, pECB, pFlagsContext, FALSE, m_pPrefixStream);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
SaveStreamToIISSocket(m_pPrefixStream, pECB, TRUE);
WRITEBSTR(m_pSuffixStream, L"</IRETURNVALUE>");
MapEnum (pEnum, 3, 0, NULL, NULL, pECB, pFlagsContext, TRUE);
}
break;
}
pEnum->Release ();
}
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
//***************************************************************************
//
// SCODE CXMLTranslator::ReferenceNames
//
// DESCRIPTION:
//
// Performs an "REFERENCES OF" query, gets the names and transforms the
/// result into XML
//
// PARAMETERS:
//
// pszNamespacePath The namespace path in which the object resides.
// pszObjectName The object whose assocaitors are required
// pXML On successful return addresses the XML document.
// The caller is responsible for freeing this BSTR
// using SysFreeString.
//
// RETURN VALUES:
//
// WBEM_S_NO_ERROR success, XML document is addressed by pXML
// WBEM_E_INVALID_PARAMETER bad input parameters
// WBEM_E_FAILED otherwise
//
// Other WBEM error codes may be returned by ConnectServer etc., in which
// case these are passed on to the caller.
//
//***************************************************************************
HRESULT CXMLTranslator::ReferenceNames (
BSTR pszNamespacePath,
BSTR pszObjectName,
BSTR pszResultClass,
BSTR pszRole,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
HRESULT hr = WBEM_E_FAILED;
if ((NULL == pszNamespacePath) || (NULL == pszObjectName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Perform the query
IEnumWbemClassObject *pEnum = NULL;
BSTR bsQueryLang = SysAllocString(L"WQL");
// Build the ASSOCIATORS OF query
BSTR bsQuery = FormatReferencesQuery (pszObjectName, pszResultClass,
pszRole, FALSE, FALSE, NULL);
// RAJESHR - Use semi sync and Forward only enumerator?
if(SUCCEEDED(hr = pService->ExecQuery (bsQueryLang, bsQuery, 0, pContext, &pEnum)))
{
// Ensure we have impersonation enabled
DWORD dwAuthnLevel, dwImpLevel;
GetAuthImp (pEnum, &dwAuthnLevel, &dwImpLevel);
if (RPC_C_IMP_LEVEL_IMPERSONATE != dwImpLevel)
SetInterfaceSecurity (pEnum, NULL, NULL, NULL, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, EOAC_STATIC_CLOAKING);
switch(m_iHttpVersion)
{
// We write everything on to the prefix stream since there is no
// chunked encoding in HTTP 1.0
case WMI_XML_HTTP_VERSION_1_0:
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
// Now do the translation
MapEnumNames (m_pPrefixStream, pEnum, 3, pFlagsContext);
WRITEBSTR(m_pPrefixStream, L"</IRETURNVALUE>");
}
break;
case WMI_XML_HTTP_VERSION_1_1:
{
// Create a stream
IStream *pStream = NULL;
if (SUCCEEDED(hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream)))
{
// Now do the translation
if (SUCCEEDED(MapEnumNames (pStream, pEnum, 3, pFlagsContext)))
{
// First Write an IRETURNVALUE to the Prefix Stream
WRITEBSTR(m_pPrefixStream, L"<IRETURNVALUE>");
WRITEBSTR(pStream, L"</IRETURNVALUE>");
// Write the translation to the IIS Socket
SavePrefixAndBodyToIISSocket(m_pPrefixStream, pStream, pECB, m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1);
}
pStream->Release ();
}
}
break;
}
pEnum->Release ();
}
SysFreeString (bsQueryLang);
SysFreeString (bsQuery);
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(FAILED(hr) && m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
return hr;
}
HRESULT CXMLTranslator::ExecuteMethod (
BSTR pszNamespacePath,
BSTR pszObjPath,
BSTR pszMethodName,
BOOLEAN isStaticMethod,
CParameterMap *pParameterMap,
LPEXTENSION_CONTROL_BLOCK pECB,
IWbemContext *pFlagsContext
)
{
// In case of HTTP 1.1, We have to ensure that we write thr contents of m_pPrefixStream to the socket irrespective of whether the call failed or not
if(m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1)
SavePrefixAndBodyToIISSocket(m_pPrefixStream, NULL, pECB, TRUE);
HRESULT hr = WBEM_E_FAILED;
if ( (NULL == pszNamespacePath) || (NULL == pszObjPath) || (NULL == pszMethodName))
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
// Create an IWbemContext Object if the client is WMI
IWbemContext *pContext = NULL;
if(m_pContext)
hr = CXmlToWmi::MapContextObject(m_pContext, &pContext);
if(SUCCEEDED(hr))
{
// Get the class to get at the method definition
IWbemClassObject *pClass = NULL;
IWbemClassObject *pInstance = NULL;
if(isStaticMethod)
{
hr = pService->GetObject(pszObjPath, 0, 0, &pClass, NULL);
}
else
{
if(SUCCEEDED(hr = pService->GetObject(pszObjPath, 0, 0, &pInstance, NULL)))
{
// Get the __CLASS property
BSTR strClassProp = NULL;
if(strClassProp = SysAllocString(L"__CLASS"))
{
VARIANT classNameVariant;
VariantInit(&classNameVariant);
if(SUCCEEDED(hr = pInstance->Get(strClassProp, 0, &classNameVariant, NULL, NULL)))
{
hr = pService->GetObject(classNameVariant.bstrVal, 0, 0, &pClass, NULL);
VariantClear(&classNameVariant);
}
SysFreeString(strClassProp);
}
else
hr = E_OUTOFMEMORY;
}
}
// Now we have the class definition. Get the Method definition
if(SUCCEEDED(hr))
{
IWbemClassObject *pInSignature = NULL;
if(SUCCEEDED(hr = pClass->GetMethod(pszMethodName, 0, &pInSignature, NULL)))
{
// Form an instance for the input parameters
IWbemClassObject *pMethodParameters = NULL;
if(SUCCEEDED(hr = FormMethodParameters(pszNamespacePath, pInSignature, pParameterMap, &pMethodParameters)))
{
IWbemClassObject *pOutputParameters= NULL;
if(SUCCEEDED(hr = pService->ExecMethod(pszObjPath, pszMethodName, 0, pContext, pMethodParameters, &pOutputParameters, NULL)))
{
// We dont use chunked encoding for ExecMethod responses
// Instead we write everything to the prefix stream for HTTP1.0 or the Suffix stream for HTTP 1.1
// Create the convertor
IWbemXMLConvertor *pConvertor = NULL;
if(SUCCEEDED(hr = CreateXMLTranslator(&pConvertor)))
{
// Now do the translation
if (SUCCEEDED(hr = pConvertor->MapMethodResultToXML(pOutputParameters, pFlagsContext,
(m_iHttpVersion == WMI_XML_HTTP_VERSION_1_1) ? m_pSuffixStream : m_pPrefixStream)))
{
}
pConvertor->Release();
}
pOutputParameters->Release();
}
pMethodParameters->Release();
}
pInSignature->Release();
}
}
// Release the instance and class associated with this method
if(pClass)
pClass->Release();
if(pInstance)
pInstance->Release();
}
// Release the IWbemContext object, if any
if(pContext)
pContext->Release();
pService->Release();
}
}
return hr;
}
// Take the paramters from the input map and fill them into the IWbemClassObject
HRESULT CXMLTranslator::FormMethodParameters(
BSTR pszNamespacePath,
IWbemClassObject *pInSignature,
CParameterMap *pParameterMap,
IWbemClassObject **ppMethodParameters)
{
HRESULT hr = WBEM_E_FAILED;
*ppMethodParameters = NULL;
if(SUCCEEDED(hr = pInSignature->SpawnInstance(0, ppMethodParameters)))
{
if(SUCCEEDED(hr = pInSignature->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY)))
{
BSTR strName = NULL;
VARIANT variant;
VariantInit(&variant);
CIMTYPE cimType;
while(SUCCEEDED(hr = pInSignature->Next(0, &strName, &variant, &cimType, NULL)) && hr != WBEM_S_NO_MORE_DATA)
{
// Get the property from the property map
// We get one of (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY|VALUE.OBJECT|VALUE.OBJECTARRAY)
// in pPropertyValue
IXMLDOMNode *pPropertyValue = NULL;
if(pParameterMap->Lookup(strName, pPropertyValue))
{
// Map the parameter value to the property value
switch(cimType)
{
case CIM_SINT8:
case CIM_UINT8:
case CIM_SINT16:
case CIM_UINT16:
case CIM_UINT32:
case CIM_SINT32:
case CIM_REAL32:
case CIM_REAL64:
case CIM_BOOLEAN:
case CIM_STRING:
case CIM_DATETIME:
{
BSTR strPropertyValue = NULL;
if(SUCCEEDED(pPropertyValue->get_text(&strPropertyValue)))
{
hr = CXmlToWmi::MapStringValue(strPropertyValue, variant, cimType);
SysFreeString(strPropertyValue);
}
}
break;
case CIM_SINT8|CIM_FLAG_ARRAY:
case CIM_UINT8|CIM_FLAG_ARRAY:
case CIM_SINT16|CIM_FLAG_ARRAY:
case CIM_UINT16|CIM_FLAG_ARRAY:
case CIM_UINT32|CIM_FLAG_ARRAY:
case CIM_SINT32|CIM_FLAG_ARRAY:
case CIM_REAL32|CIM_FLAG_ARRAY:
case CIM_REAL64|CIM_FLAG_ARRAY:
case CIM_BOOLEAN|CIM_FLAG_ARRAY:
case CIM_STRING|CIM_FLAG_ARRAY:
case CIM_DATETIME|CIM_FLAG_ARRAY:
hr = CXmlToWmi::MapStringArrayValue(pPropertyValue, variant, cimType);
break;
case CIM_REFERENCE:
hr = CXmlToWmi::MapReferenceValue(pPropertyValue, variant);
break;
case CIM_REFERENCE|CIM_FLAG_ARRAY:
hr = CXmlToWmi::MapReferenceArrayValue(pPropertyValue, variant);
break;
case CIM_OBJECT:
case CIM_OBJECT|CIM_FLAG_ARRAY:
{
// Ugh - these types require us to connect to Cimom to fetch the class of the embedded object
// Connect to the requested namespace
IWbemServices *pService = NULL;
if (SUCCEEDED (hr = m_connectionCache.GetConnectionByPath (pszNamespacePath, &pService)))
{
CXmlToWmi xmlToWmi;
if(SUCCEEDED(hr = xmlToWmi.Initialize(NULL, pService, NULL)))
{
if(cimType == CIM_OBJECT)
hr = xmlToWmi.MapObjectValue(pPropertyValue, variant);
else
hr = xmlToWmi.MapObjectArrayValue(pPropertyValue, variant);
}
pService->Release();
}
}
break;
}
if(SUCCEEDED(hr))
hr = (*ppMethodParameters)->Put(strName, 0, &variant, NULL);
// No Need to delete/release the result of the call to LookUp()
// since we're only using pointers
}
VariantClear(&variant);
SysFreeString(strName);
}
pInSignature->EndEnumeration();
}
}
if(FAILED(hr))
{
if(*ppMethodParameters)
(*ppMethodParameters)->Release();
}
return hr;
}
WCHAR *BuildPropertyList (DWORD dwNumProperties, BSTR *pPropertyArray)
{
WCHAR *pstrPropertyList = NULL;
DWORD dwTotalMemory = 0;
// Go thru the list and collect the amount of memory required for converting
// this list of property names into a comma-separated list (one for the comma)
for (DWORD i = 0; i < dwNumProperties; i++)
dwTotalMemory += wcslen(pPropertyArray [i]);
if (dwTotalMemory)
{
if(pstrPropertyList = new WCHAR[dwTotalMemory + dwNumProperties])
{
pstrPropertyList [0] = NULL;
for(i=0; i<dwNumProperties; i++)
{
wcscat(pstrPropertyList, pPropertyArray[i]);
if(i != dwNumProperties-1)
wcscat(pstrPropertyList, L",");
}
}
}
return pstrPropertyList;
}
//***************************************************************************
//
// BSTR FormatAssociatorsQuery
//
// Description:
//
// Takes the parameters to an AssociatorsOf call and constructs a WQL
// query string from them.
//
// Returns: The constructed WQL query; this must be freed using
// SysFreeString by the caller.
//
// pdispparams the input dispatch parameters
//
//***************************************************************************
BSTR FormatAssociatorsQuery
(
BSTR strObjectPath,
BSTR strAssocClass,
BSTR strResultClass,
BSTR strResultRole,
BSTR strRole,
VARIANT_BOOL bClassesOnly,
VARIANT_BOOL bSchemaOnly,
BSTR strRequiredAssocQualifier,
BSTR strRequiredQualifier
)
{
BSTR bsQuery = NULL;
// Get the length of the string:
// associators of {SourceObject} where
// AssocClass = AssocClassName
// ClassDefsOnly
// SchemaOnly
// RequiredAssocQualifier = QualifierName
// RequiredQualifier = QualifierName
// ResultClass = ClassName
// ResultRole = PropertyName
// Role = PropertyName
long queryLength = 1; // Terminating NULL
queryLength += wcslen (WMIXML_QUERY_ASSOCOF) +
wcslen (WMIXML_QUERY_OPENBRACE) +
wcslen (WMIXML_QUERY_CLOSEBRACE) +
wcslen (strObjectPath);
BOOL needWhere = FALSE;
if ((strAssocClass && (0 < wcslen (strAssocClass))) ||
(strResultClass && (0 < wcslen (strResultClass))) ||
(strResultRole && (0 < wcslen (strResultRole))) ||
(strRole && (0 < wcslen (strRole))) ||
(VARIANT_FALSE != bClassesOnly) ||
(VARIANT_FALSE != bSchemaOnly) ||
(strRequiredAssocQualifier && (0 < wcslen (strRequiredAssocQualifier))) ||
(strRequiredQualifier && (0 < wcslen (strRequiredQualifier))))
{
needWhere = TRUE;
queryLength += wcslen (WMIXML_QUERY_WHERE);
}
if (strAssocClass && (0 < wcslen (strAssocClass)))
queryLength += wcslen (WMIXML_QUERY_ASSOCCLASS) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strAssocClass);
if (strResultClass && (0 < wcslen (strResultClass)))
queryLength += wcslen (WMIXML_QUERY_RESCLASS) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strResultClass);
if (strResultRole && (0 < wcslen (strResultRole)))
queryLength += wcslen (WMIXML_QUERY_RESROLE) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strResultRole);
if (strRole && (0 < wcslen (strRole)))
queryLength += wcslen (WMIXML_QUERY_ROLE) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strRole);
if (VARIANT_FALSE != bClassesOnly)
queryLength += wcslen (WMIXML_QUERY_CLASSDEFS);
if (VARIANT_FALSE != bSchemaOnly)
queryLength += wcslen (WMIXML_QUERY_SCHEMAONLY);
if (strRequiredAssocQualifier && (0 < wcslen (strRequiredAssocQualifier)))
queryLength += wcslen (WMIXML_QUERY_REQASSOCQ) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strRequiredAssocQualifier);
if (strRequiredQualifier && (0 < wcslen (strRequiredQualifier)))
queryLength += wcslen (WMIXML_QUERY_REQQUAL) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strRequiredQualifier);
// Allocate the string and fill it in
bsQuery = SysAllocStringLen (WMIXML_QUERY_ASSOCOF, queryLength);
wcscat (bsQuery, WMIXML_QUERY_OPENBRACE);
wcscat (bsQuery, strObjectPath);
wcscat (bsQuery, WMIXML_QUERY_CLOSEBRACE);
if (needWhere)
{
wcscat (bsQuery, WMIXML_QUERY_WHERE);
if (strAssocClass && (0 < wcslen (strAssocClass)))
{
wcscat (bsQuery, WMIXML_QUERY_ASSOCCLASS);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strAssocClass);
}
if (strResultClass && (0 < wcslen (strResultClass)))
{
wcscat (bsQuery, WMIXML_QUERY_RESCLASS);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strResultClass);
}
if (strResultRole && (0 < wcslen (strResultRole)))
{
wcscat (bsQuery, WMIXML_QUERY_RESROLE);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strResultRole);
}
if (strRole && (0 < wcslen (strRole)))
{
wcscat (bsQuery, WMIXML_QUERY_ROLE);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strRole);
}
if (VARIANT_FALSE != bClassesOnly)
wcscat (bsQuery, WMIXML_QUERY_CLASSDEFS);
if (VARIANT_FALSE != bSchemaOnly)
wcscat (bsQuery, WMIXML_QUERY_SCHEMAONLY);
if (strRequiredAssocQualifier && (0 < wcslen (strRequiredAssocQualifier)))
{
wcscat (bsQuery, WMIXML_QUERY_REQASSOCQ);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strRequiredAssocQualifier);
}
if (strRequiredQualifier && (0 < wcslen (strRequiredQualifier)))
{
wcscat (bsQuery, WMIXML_QUERY_REQQUAL);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strRequiredQualifier);
}
}
return bsQuery;
}
//***************************************************************************
//
// BSTR FormatReferencesQuery
//
// Description:
//
// Takes the parameters to an ReferencesOf call and constructs a WQL
// query string from them.
//
// Returns: The constructed WQL query; this must be freed using
// SysFreeString by the caller.
//
// pdispparams the input dispatch parameters
//
//***************************************************************************
BSTR FormatReferencesQuery
(
BSTR strObjectPath,
BSTR strResultClass,
BSTR strRole,
VARIANT_BOOL bClassesOnly,
VARIANT_BOOL bSchemaOnly,
BSTR strRequiredQualifier
)
{
BSTR bsQuery = NULL;
// Get the length of the string:
// references of {SourceObject} where
// ClassDefsOnly
// SchemaOnly
// RequiredQualifier = QualifierName
// ResultClass = ClassName
// Role = PropertyName
long queryLength = 1; // Terminating NULL
queryLength += wcslen (WMIXML_QUERY_REFOF) +
wcslen (WMIXML_QUERY_OPENBRACE) +
wcslen (WMIXML_QUERY_CLOSEBRACE) +
wcslen (strObjectPath);
BOOL needWhere = FALSE;
if ((strResultClass && (0 < wcslen (strResultClass))) ||
(strRole && (0 < wcslen (strRole))) ||
(VARIANT_FALSE != bClassesOnly) ||
(VARIANT_FALSE != bSchemaOnly) ||
(strRequiredQualifier && (0 < wcslen (strRequiredQualifier))))
{
needWhere = TRUE;
queryLength += wcslen (WMIXML_QUERY_WHERE);
}
if (strResultClass && (0 < wcslen (strResultClass)))
queryLength += wcslen (WMIXML_QUERY_RESCLASS) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strResultClass);
if (strRole && (0 < wcslen (strRole)))
queryLength += wcslen (WMIXML_QUERY_ROLE) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strRole);
if (VARIANT_FALSE != bClassesOnly)
queryLength += wcslen (WMIXML_QUERY_CLASSDEFS);
if (VARIANT_FALSE != bSchemaOnly)
queryLength += wcslen (WMIXML_QUERY_SCHEMAONLY);
if (strRequiredQualifier && (0 < wcslen (strRequiredQualifier)))
queryLength += wcslen (WMIXML_QUERY_REQQUAL) +
wcslen (WMIXML_QUERY_EQUALS) +
wcslen (strRequiredQualifier);
// Allocate the string and fill it in
bsQuery = SysAllocStringLen (WMIXML_QUERY_REFOF, queryLength);
wcscat (bsQuery, WMIXML_QUERY_OPENBRACE);
wcscat (bsQuery, strObjectPath);
wcscat (bsQuery, WMIXML_QUERY_CLOSEBRACE);
if (needWhere)
{
wcscat (bsQuery, WMIXML_QUERY_WHERE);
if (strResultClass && (0 < wcslen (strResultClass)))
{
wcscat (bsQuery, WMIXML_QUERY_RESCLASS);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strResultClass);
}
if (strRole && (0 < wcslen (strRole)))
{
wcscat (bsQuery, WMIXML_QUERY_ROLE);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strRole);
}
if (VARIANT_FALSE != bClassesOnly)
wcscat (bsQuery, WMIXML_QUERY_CLASSDEFS);
if (VARIANT_FALSE != bSchemaOnly)
wcscat (bsQuery, WMIXML_QUERY_SCHEMAONLY);
if (strRequiredQualifier && (0 < wcslen (strRequiredQualifier)))
{
wcscat (bsQuery, WMIXML_QUERY_REQQUAL);
wcscat (bsQuery, WMIXML_QUERY_EQUALS);
wcscat (bsQuery, strRequiredQualifier);
}
}
return bsQuery;
}
BOOL CXMLTranslator::TransformQuery (BSTR *pbsQueryString) // , bool &bGenusAdded, bool&bClassAdded)
{
return FALSE;
/*
bGenusAdded = true;
bClassAdded = true;
BOOL result = FALSE;
// The problem we're facing here is the case where projected queries are used
// In this case, what happens is that the projection list might be missing one of the
// following system properties that are required by us for generating VALUE.OBJECTs:
// __GENUS : We need this to decide whether to generate CLASS or INSTANCE tag
// __CLASS : We need this for the NAME attribute of a CLASS or INSTANCE
// __SUPERCLASS : We need this for a CLASS tag. But it is not mandatory
// If we are doing a select, make sure we add in __CLASS, __GENUS and __SUPERCLASS
// However, we also face the problem, that these might or might not have been present in the
// list of properties in the projection. If they were present, then we're fine. Otherwise,
// we need to remove them in the final conversion to XML
IWbemQuery *pQuery = NULL;
HRESULT hr = CoCreateInstance(CLSID_WbemQuery, 0, CLSCTX_INPROC_SERVER,
IID_IWbemQuery, (LPVOID *) &pQuery);
if(SUCCEEDED(hr))
{
// Parse it to get the properties in the projection list
if(SUCCEEDED(hr = pQuery->SetLanguageFeatures(0, sizeof(uFeatures)/sizeof(ULONG), uFeatures)))
{
if(SUCCEEDED(hr = pQuery->Parse(L"SQL", *pbsQueryString, 0)))
{
SWbemRpnEncodedQuery *pRpn = NULL;
if(SUCCEEDED(hr = pQuery->GetAnalysis(
WMIQ_ANALYSIS_RPN_SEQUENCE,
0,
(LPVOID *) &pRpn
)))
{
// Go thru the list, looking for __GENUS and __CLASS
for(ULONG i=0; i<pRpn->m_uSelectListSize; i++)
{
SWbemQueryQualifiedName *p = pRpn->m_ppSelectList[i];
if(_wcsicmp(p->m_ppszNameList[0], L"*") == 0)
{
bClassAdded = false;
bGenusAdded = false;
break;
}
else if(_wcsicmp(p->m_ppszNameList[0], L"__GENUS") == 0)
bGenusAdded = false;
else if(_wcsicmp(p->m_ppszNameList[0], L"__CLASS") == 0)
bClassAdded = false;
}
pQuery->FreeMemory(pRpn);
}
}
}
pQuery->Release();
}
// Now we know whether __GENUS and __CLASS occured.
if(bGenusAdded && bClassAdded)
result = AddClause(L"select __GENUS, __CLASS, ");
else if(bGenusAdded)
result = AddClause(L"select __GENUS, ");
else if(bClassAdded)
result = AddClause(L"select __CLASS, ");
return result;
*/
}
BOOL AddClause(BSTR *pbsQueryString, LPCWSTR pszClause)
{
BOOL result = FALSE;
// RAJESHR - We're currently Hand-inserting clauses into the query.
// We should be really having an Unparse() in Core team's Query parser
int i = 0;
int len = wcslen (*pbsQueryString);
// Move to the first space past the "select" token
while ((i < len) && iswspace ((*pbsQueryString) [i]))
i++;
// See if the token was really "select"
if ((i < len) && (0 == _wcsnicmp (L"select", &((*pbsQueryString) [i]), wcslen(L"select"))))
{
i += wcslen (L"select");
// Move past the white spaces after "select"
while ((i < len) && iswspace ((*pbsQueryString) [i]))
i++;
// Need to add in the system properties
WCHAR *pNewQuery = NULL;
if(pNewQuery = new WCHAR [wcslen (&((*pbsQueryString) [i])) +
wcslen (pszClause) + 1])
{
wcscpy (pNewQuery, pszClause);
wcscat (pNewQuery, &((*pbsQueryString) [i]));
*pbsQueryString = NULL;
if(*pbsQueryString = SysAllocString (pNewQuery))
result = TRUE;
delete [] pNewQuery;
}
}
return result;
}
Reference in New Issue View Git Blame Copy Permalink