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

3361 lines
98 KiB
C++
Raw Permalink Blame History

//***************************************************************************
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// PARSE.CPP
//
// rajesh 3/25/2000 Created.
//
// Contains the functions for parsing XML Requests that conform to the CIM DTD or WMI (Nova and WHistler)
// DTDs
//
//***************************************************************************
#include <windows.h>
#include <httpext.h>
#include <mshtml.h>
#include <msxml.h>
#include <objbase.h>
#include <initguid.h>
#include <wbemcli.h>
#include "provtempl.h"
#include "common.h"
#include "strings.h"
#include "errors.h"
#include "wmixmlop.h"
#include "wmiconv.h"
#include "request.h"
#include "whistler.h"
#include "xmlhelp.h"
#include "parse.h"
// Forward declarations of parsers for smaller constructs
// These are static functions and are used only in this file
//============================================================
static BOOLEAN ParseMultiReq(IXMLDOMNodeList *pReqList, CCimHttpMultiMessage *pMultiRequest, BSTR strID, BOOLEAN bIsMpostRequest, BOOLEAN bIsMicrosoftWMIClient, WMI_XML_HTTP_VERSION iHttpVersion, DWORD dwNumSimpleRequests);
static CCimHttpMessage * ParseSimpleReq(IXMLDOMNode *pNode, BSTR strID, BOOLEAN bIsMpostRequest, BOOLEAN bIsMicrosoftWMIClient, WMI_XML_HTTP_VERSION iHttpVersion);
static CCimHttpMessage * ParseIMethodCall(IXMLDOMNode *pMethodNode, BSTR strID);
static CCimHttpMessage * ParseMethodCall(IXMLDOMNode *pMethodNode, BSTR strID);
HRESULT ParseLongArgument(IXMLDOMNode *pNode, long *plArgVal)
{
HRESULT hr = E_FAIL;
BSTR strStringVal = NULL;
if(SUCCEEDED(hr = pNode->get_text(&strStringVal)))
{
// Convert it to a long value
*plArgVal = (long) wcstol (strStringVal, NULL, 0);
SysFreeString(strStringVal);
}
return hr;
}
// Parse one key value
HRESULT ParseKeyValue(IXMLDOMNode *pNode, BSTR *ppszValue)
{
HRESULT result = E_FAIL;
BSTR strType = NULL;
*ppszValue = NULL;
// This is an optional attribute and the default is "string"
BOOLEAN isString = TRUE;
if(SUCCEEDED(GetBstrAttribute(pNode, VALUE_TYPE_ATTRIBUTE, &strType)))
{
if(_wcsicmp(strType, STRING_TYPE) != 0)
{
isString = FALSE;
SysFreeString(strType);
}
}
if(isString) // Escape the appropriate characters and enclose it in double-quotes
{
LPWSTR pszReturnValue = NULL;
BSTR strTemp = NULL;
if(SUCCEEDED(result = pNode->get_text(&strTemp)))
{
BSTR strEscapedTemp = NULL;
if(strEscapedTemp = EscapeSpecialCharacters(strTemp))
{
if(pszReturnValue = new WCHAR[wcslen(strEscapedTemp) + 3])
{
wcscpy(pszReturnValue, QUOTE_SIGN);
wcscat(pszReturnValue, strEscapedTemp);
wcscat(pszReturnValue, QUOTE_SIGN);
if(!(*ppszValue = SysAllocString(pszReturnValue)))
result = E_OUTOFMEMORY;
delete [] pszReturnValue;
}
else
result = E_OUTOFMEMORY;
SysFreeString(strEscapedTemp);
}
else
result = E_OUTOFMEMORY;
SysFreeString(strTemp);
}
}
else // BOOLEAN or Numeric
{
result = pNode->get_text(ppszValue);
}
return result;
}
// Parse one value The only difference between this and ParseKeyValue is that strings are not enclsed in quotes
HRESULT ParseValue(IXMLDOMNode *pNode, BSTR *ppszValue)
{
HRESULT result = E_FAIL;
BSTR strType = NULL;
*ppszValue = NULL;
BOOLEAN isString = FALSE;
if(SUCCEEDED(result = GetBstrAttribute(pNode, VALUE_TYPE_ATTRIBUTE, &strType)))
{
if(_wcsicmp(strType, STRING_TYPE) == 0) // Enclose it in double-quotes
isString = TRUE;
SysFreeString(strType);
}
else // It's a string by default
{
isString = TRUE;
}
if(isString) // Escape the appropriate characters and enclose it in double-quotes
{
LPWSTR pszReturnValue = NULL;
BSTR strTemp = NULL;
if(SUCCEEDED(result = pNode->get_text(&strTemp)))
{
if(!(*ppszValue = EscapeSpecialCharacters(strTemp)))
result = E_OUTOFMEMORY;
SysFreeString(strTemp);
}
}
else // BOOLEAN or Numeric
{
result = pNode->get_text(ppszValue);
}
return result;
}
// Parse one key binding. Return <propName>=<value>
// The key binding is either a KEYVALUE or a VALUE.REFERENCE tag
HRESULT ParseOneKeyBinding(IXMLDOMNode *pNode, LPWSTR *ppszValue)
{
HRESULT result = E_FAIL;
*ppszValue = NULL;
// First get the property name
BSTR strPropertyName = NULL;
if(SUCCEEDED(result = GetBstrAttribute(pNode, NAME_ATTRIBUTE, &strPropertyName)))
{
// See if the child is a KEYVALUE or VALUE.REFERENCE
IXMLDOMNode *pChildNode = NULL;
if(SUCCEEDED(pNode->get_firstChild(&pChildNode)) && pChildNode)
{
BSTR strNodeName = NULL;
if(SUCCEEDED(pChildNode->get_nodeName(&strNodeName)))
{
// Look ahead
if(_wcsicmp(strNodeName, KEYVALUE_TAG) == 0)
{
BSTR strValue = NULL;
if(SUCCEEDED(result = ParseKeyValue(pChildNode, &strValue)))
{
// COncatenate them with an '=' inbetween
if(*ppszValue = new WCHAR [ wcslen(strPropertyName) + wcslen(strValue) + 2])
{
wcscpy(*ppszValue, strPropertyName);
wcscat(*ppszValue, EQUALS_SIGN);
wcscat(*ppszValue, strValue);
}
else
result = E_OUTOFMEMORY;
SysFreeString(strValue);
}
}
else if (_wcsicmp(strNodeName, VALUEREFERENCE_TAG) == 0)
{
BSTR strValue = NULL;
if(SUCCEEDED(result = ParseOneReferenceValue (pChildNode, &strValue)))
{
if(*ppszValue = new WCHAR [ wcslen(strValue) + 1])
wcscpy(*ppszValue, strValue);
else
result = E_OUTOFMEMORY;
SysFreeString(strValue);
}
}
SysFreeString(strNodeName);
}
pChildNode->Release();
}
SysFreeString(strPropertyName);
}
return result;
}
HRESULT ParseClassName (IXMLDOMNode *pNode, BSTR *pstrValue)
{
HRESULT hr = WBEM_E_FAILED;
*pstrValue = NULL;
if(pNode && SUCCEEDED(GetBstrAttribute(pNode, NAME_ATTRIBUTE, pstrValue)))
hr = S_OK;
return hr;
}
// Given a VALUE.REFERENCE element, it creates a string representation of the element
// The string representation is the WMI object path representation
HRESULT ParseOneReferenceValue (IXMLDOMNode *pValueRef, BSTR *pstrValue)
{
HRESULT hr = E_FAIL;
// Let's look at the child of the VALUE.REFERENCE tag
IXMLDOMNode *pChild = NULL;
if (SUCCEEDED(pValueRef->get_firstChild (&pChild)) && pChild)
{
// Next node could be a CLASSPATH, LOCALCLASSPATH, INSTANCEPATH,
// LOCALINSTANCEPATH, CLASSNAME or INSTANCENAME
// or even a VALUE (for Scoped and UMI paths)
BSTR strNodeName = NULL;
if(SUCCEEDED(pChild->get_nodeName(&strNodeName)))
{
if (_wcsicmp(strNodeName, CLASSNAME_TAG) == 0)
{
hr = ParseClassName (pChild, pstrValue);
}
else if (_wcsicmp(strNodeName, LOCALCLASSPATH_TAG) == 0)
{
hr = ParseLocalClassPath (pChild, pstrValue);
}
else if (_wcsicmp(strNodeName, CLASSPATH_TAG) == 0)
{
hr = ParseClassPath (pChild, pstrValue);
}
else if (_wcsicmp(strNodeName, INSTANCENAME_TAG) == 0)
{
hr = ParseInstanceName (pChild, pstrValue);
}
else if (_wcsicmp(strNodeName, LOCALINSTANCEPATH_TAG) == 0)
{
hr = ParseLocalInstancePath (pChild, pstrValue);
}
else if (_wcsicmp(strNodeName, INSTANCEPATH_TAG) == 0)
{
hr = ParseInstancePath (pChild, pstrValue);
}
else if (_wcsicmp(strNodeName, VALUE_TAG) == 0)
{
// Just get its contents
// RAJESHR - what if it is escaped CDATA? We need to unescape it
hr = pChild->get_text(pstrValue);
}
SysFreeString(strNodeName);
}
pChild->Release();
}
return hr;
}
// Given a LOCALCLASSPATH element, gets its WMI object path representation
HRESULT ParseLocalClassPath (IXMLDOMNode *pNode, BSTR *pstrValue)
{
HRESULT hr = WBEM_E_FAILED;
// Expecting (LOCALNAMESPACEPATH followed by CLASSNAME
IXMLDOMNodeList *pNodeList = NULL;
if (pNode && SUCCEEDED(pNode->get_childNodes (&pNodeList)) && pNodeList)
{
IXMLDOMNode *pLocalNSPathNode = NULL;
// Next node should be a LOCALNAMESPACEPATH
if (SUCCEEDED(pNodeList->nextNode (&pLocalNSPathNode)) && pLocalNSPathNode)
{
BSTR strNSNodeName = NULL;
if (SUCCEEDED(pLocalNSPathNode->get_nodeName(&strNSNodeName)) &&
strNSNodeName && (_wcsicmp(strNSNodeName, LOCALNAMESPACEPATH_TAG) == 0))
{
BSTR strLocalNamespace = NULL;
ParseLocalNamespacePath(pLocalNSPathNode, &strLocalNamespace);
// Next node should be the classname
IXMLDOMNode *pClassNameNode = NULL;
if (SUCCEEDED(pNodeList->nextNode (&pClassNameNode)) && pClassNameNode)
{
BSTR strNSClassName = NULL;
if (SUCCEEDED(pClassNameNode->get_nodeName(&strNSClassName)) &&
strNSClassName && (_wcsicmp(strNSClassName, CLASSNAME_TAG) == 0))
{
BSTR strClassName = NULL;
if (SUCCEEDED(GetBstrAttribute (pClassNameNode,
NAME_ATTRIBUTE, &strClassName)))
{
// Phew - finally we have all the info!
LPWSTR pPath = NULL;
if(pPath = new WCHAR [wcslen(strLocalNamespace)
+ wcslen(strClassName) + 2])
{
wcscpy (pPath, strLocalNamespace);
wcscat (pPath, L":");
wcscat (pPath, strClassName);
*pstrValue = NULL;
if(*pstrValue = SysAllocString (pPath))
hr = S_OK;
else
hr = E_OUTOFMEMORY;
delete [] pPath;
}
else
hr = E_OUTOFMEMORY;
SysFreeString (strClassName);
}
}
pClassNameNode->Release ();
SysFreeString (strNSClassName);
}
SysFreeString (strLocalNamespace);
SysFreeString (strNSNodeName);
}
pLocalNSPathNode->Release ();
}
pNodeList->Release ();
}
return hr;
}
// Takes a CLASSPATH element and gets its WMI object path representation
HRESULT ParseClassPath (IXMLDOMNode *pNode, BSTR *pstrValue)
{
HRESULT hr = WBEM_E_FAILED;
// Expecting (NAMESPACEPATH followed by CLASSNAME
IXMLDOMNodeList *pNodeList = NULL;
if (pNode && SUCCEEDED(pNode->get_childNodes (&pNodeList)) && pNodeList)
{
IXMLDOMNode *pNSPathNode = NULL;
// Next node should be a NAMESPACEPATH
if (SUCCEEDED(pNodeList->nextNode (&pNSPathNode)) && pNSPathNode)
{
BSTR strNSNodeName = NULL;
if (SUCCEEDED(pNSPathNode->get_nodeName(&strNSNodeName)) &&
strNSNodeName && (_wcsicmp(strNSNodeName, NAMESPACEPATH_TAG) == 0))
{
BSTR strHost = NULL;
BSTR strNamespace = NULL;
if (SUCCEEDED (hr = ParseNamespacePath(pNSPathNode, &strHost, &strNamespace)))
{
// Next node should be the CLASSNAME
IXMLDOMNode *pClassNameNode = NULL;
if (SUCCEEDED(pNodeList->nextNode (&pClassNameNode)) && pClassNameNode)
{
BSTR strNSClassName = NULL;
if (SUCCEEDED(pClassNameNode->get_nodeName(&strNSClassName)) &&
strNSClassName && (_wcsicmp(strNSClassName, CLASSNAME_TAG) == 0))
{
BSTR strClassName = NULL;
if (SUCCEEDED(GetBstrAttribute (pClassNameNode,
NAME_ATTRIBUTE, &strClassName)))
{
// Phew - finally we have all the info!
LPWSTR pPath = NULL;
if(pPath = new WCHAR [wcslen(strHost)
+ wcslen(strNamespace) + wcslen(strClassName) + 5])
{
wcscpy (pPath, L"\\\\");
wcscat (pPath, strHost);
wcscat (pPath, L"\\");
wcscat (pPath, strNamespace);
wcscat (pPath, L":");
wcscat (pPath, strClassName);
*pstrValue = NULL;
if(*pstrValue = SysAllocString (pPath))
hr = S_OK;
else
hr = E_OUTOFMEMORY;
delete [] pPath;
}
else
hr = E_OUTOFMEMORY;
SysFreeString (strClassName);
}
SysFreeString (strNSClassName);
}
pClassNameNode->Release ();
}
SysFreeString (strHost);
SysFreeString (strNamespace);
}
SysFreeString (strNSNodeName);
}
pNSPathNode->Release ();
}
pNodeList->Release ();
}
return hr;
}
// Parse an instance nameest
HRESULT ParseKeyBinding(IXMLDOMNode *pNode, BSTR strClassName, BSTR *pstrInstanceName)
{
HRESULT result = E_FAIL;
LPWSTR pszInstanceName = NULL;
if(!(pszInstanceName = new WCHAR [ wcslen(strClassName) + 2]))
return E_OUTOFMEMORY;
wcscpy(pszInstanceName, strClassName);
wcscat(pszInstanceName, DOT_SIGN);
// Go thru each of the key bindings
//=======================================================
IXMLDOMNodeList *pBindings = NULL;
if(SUCCEEDED(result = pNode->get_childNodes(&pBindings)))
{
IXMLDOMNode *pNextBinding = NULL;
while(SUCCEEDED(result = pBindings->nextNode(&pNextBinding)) && pNextBinding)
{
LPWSTR pszNextValue = NULL;
if(result = SUCCEEDED(ParseOneKeyBinding(pNextBinding, &pszNextValue)))
{
LPWSTR pTemp = NULL;
if(pTemp = new WCHAR [wcslen(pszInstanceName) + wcslen(pszNextValue) + 2])
{
wcscpy(pTemp, pszInstanceName);
wcscat(pTemp, pszNextValue);
wcscat(pTemp, COMMA_SIGN);
delete [] pszInstanceName;
delete [] pszNextValue;
pszInstanceName = pTemp;
}
else
result = E_OUTOFMEMORY;
}
pNextBinding->Release();
pNextBinding = NULL;
if(FAILED(result))
break;
}
pBindings->Release();
}
if(SUCCEEDED(result))
{
// Get rid of the last comma
pszInstanceName[wcslen(pszInstanceName) - 1] = NULL;
if(!(*pstrInstanceName = SysAllocString(pszInstanceName)))
result = E_OUTOFMEMORY;
}
else
*pstrInstanceName = NULL;
delete [] pszInstanceName;
return result;
}
HRESULT ParseLocalNamespacePath(IXMLDOMNode *pLocalNamespaceNode, BSTR *pstrLocalNamespacePath)
{
// Go thru the children collecting the NAME attribute and concatenating
// This requires 2 passes since we dont know the length
//=============================================================
DWORD dwLength=0;
*pstrLocalNamespacePath = NULL;
HRESULT result = E_FAIL;
IXMLDOMNodeList *pChildren = NULL;
if(SUCCEEDED(result = pLocalNamespaceNode->get_childNodes(&pChildren)))
{
IXMLDOMNode *pNextChild = NULL;
while(SUCCEEDED(pChildren->nextNode(&pNextChild)) && pNextChild)
{
BSTR strAttributeValue = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextChild, NAME_ATTRIBUTE, &strAttributeValue)))
{
dwLength += wcslen(strAttributeValue);
dwLength ++; // For the back slash
SysFreeString(strAttributeValue);
}
pNextChild->Release();
pNextChild = NULL;
}
// Allocate memory
LPWSTR pszNamespaceValue = NULL;
if(pszNamespaceValue = new WCHAR[dwLength + 1])
{
pszNamespaceValue[0] = 0;
// Once more
pNextChild = NULL;
pChildren->reset();
while(SUCCEEDED(pChildren->nextNode(&pNextChild)) && pNextChild)
{
BSTR strAttributeValue = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextChild, NAME_ATTRIBUTE, &strAttributeValue)))
{
wcscat(pszNamespaceValue, strAttributeValue);
wcscat(pszNamespaceValue, BACK_SLASH_WSTR);
SysFreeString(strAttributeValue);
}
pNextChild->Release();
pNextChild = NULL;
}
// Remove the last back slash
pszNamespaceValue[dwLength-1] = NULL;
if(!(*pstrLocalNamespacePath = SysAllocString(pszNamespaceValue)))
result = E_OUTOFMEMORY;
delete [] pszNamespaceValue;
}
else
result = E_OUTOFMEMORY;
pChildren->Release();
}
return result;
}
HRESULT ParseNamespacePath(IXMLDOMNode *pLocalNamespaceNode, BSTR *pstrHost, BSTR *pstrLocalNamespace)
{
HRESULT result = E_FAIL;
*pstrHost = NULL;
*pstrLocalNamespace = NULL;
// Get the HOST name first
IXMLDOMNode *pFirstNode = NULL, *pSecondNode = NULL;
if(SUCCEEDED(pLocalNamespaceNode->get_firstChild(&pFirstNode)) && pFirstNode)
{
// Get the Namespace part
if(SUCCEEDED (pFirstNode->get_text(pstrHost)))
{
if(SUCCEEDED(pLocalNamespaceNode->get_lastChild(&pSecondNode)))
{
// Get the instance path
if(SUCCEEDED(ParseLocalNamespacePath(pSecondNode, pstrLocalNamespace)))
{
result = S_OK;
}
pSecondNode->Release();
}
}
pFirstNode->Release();
}
if(FAILED(result))
{
SysFreeString(*pstrHost);
*pstrHost = NULL;
}
return result;
}
// Parse an instance name
HRESULT ParseInstanceName(IXMLDOMNode *pNode, BSTR *pstrInstanceName)
{
HRESULT result = E_FAIL;
// First get the class name
BSTR strClassName = NULL;
if(SUCCEEDED(result = GetBstrAttribute(pNode, CLASS_NAME_ATTRIBUTE, &strClassName)))
{
// See if the child is a KEYBINDING or KEYVALUE or
IXMLDOMNode *pChildNode = NULL;
if(SUCCEEDED(result = pNode->get_firstChild(&pChildNode)) && pChildNode)
{
BSTR strNodeName = NULL;
if(SUCCEEDED(result = pChildNode->get_nodeName(&strNodeName)))
{
// Look ahead
if(_wcsicmp(strNodeName, KEYBINDING_TAG) == 0)
{
result = ParseKeyBinding(pNode, strClassName, pstrInstanceName);
}
else if (_wcsicmp(strNodeName, KEYVALUE_TAG) == 0)
{
BSTR strKeyValue = NULL;
if(SUCCEEDED(result = ParseKeyValue(pNode, &strKeyValue)))
{
LPWSTR pszInstanceName = NULL;
if(pszInstanceName = new WCHAR[wcslen(strClassName) + wcslen(strKeyValue) + 2])
{
wcscpy(pszInstanceName, strClassName);
wcscat(pszInstanceName, EQUALS_SIGN);
wcscat(pszInstanceName, strKeyValue);
if(!(*pstrInstanceName = SysAllocString(pszInstanceName)) )
result = E_OUTOFMEMORY;
delete [] pszInstanceName;
}
else
result = E_OUTOFMEMORY;
SysFreeString(strKeyValue);
}
}
SysFreeString(strNodeName);
}
pChildNode->Release();
}
SysFreeString(strClassName);
}
return result;
}
// Takes a LOCALINSTANCEPATH element and gives its WMI object path representation
HRESULT ParseLocalInstancePath (IXMLDOMNode *pNode, BSTR *pstrValue)
{
HRESULT hr = WBEM_E_FAILED;
// Expecting (LOCALNAMESPACEPATH followed by INSTANCENAME
IXMLDOMNodeList *pNodeList = NULL;
if (pNode && SUCCEEDED(pNode->get_childNodes (&pNodeList)) && pNodeList)
{
IXMLDOMNode *pLocalNSPathNode = NULL;
// Next node should be a LOCALNAMESPACEPATH
if (SUCCEEDED(pNodeList->nextNode (&pLocalNSPathNode)) && pLocalNSPathNode)
{
BSTR strNSNodeName = NULL;
if (SUCCEEDED(pLocalNSPathNode->get_nodeName(&strNSNodeName)) &&
strNSNodeName && (_wcsicmp(strNSNodeName, LOCALNAMESPACEPATH_TAG) == 0))
{
BSTR strLocalNamespace = NULL;
ParseLocalNamespacePath(pLocalNSPathNode, &strLocalNamespace);
// Next node should be the INSTANCENAME
IXMLDOMNode *pInstanceNameNode = NULL;
if (SUCCEEDED(pNodeList->nextNode (&pInstanceNameNode)) && pInstanceNameNode)
{
BSTR strNSInstanceName = NULL;
if (SUCCEEDED(pInstanceNameNode->get_nodeName(&strNSInstanceName)) &&
strNSInstanceName && (_wcsicmp(strNSInstanceName, INSTANCENAME_TAG) == 0))
{
BSTR strInstanceName = NULL;
if (SUCCEEDED(hr = ParseInstanceName (pInstanceNameNode,
&strInstanceName)))
{
// Phew - finally we have all the info!
LPWSTR pPath = NULL;
if(pPath = new WCHAR [wcslen(strLocalNamespace)
+ wcslen(strInstanceName) + 2])
{
wcscpy (pPath, strLocalNamespace);
wcscat (pPath, L":");
wcscat (pPath, strInstanceName);
*pstrValue = NULL;
if(*pstrValue = SysAllocString (pPath))
hr = S_OK;
else
hr = E_OUTOFMEMORY;
delete [] pPath;
}
else
hr = E_OUTOFMEMORY;
SysFreeString (strInstanceName);
}
SysFreeString (strNSInstanceName);
}
pInstanceNameNode->Release ();
}
SysFreeString (strLocalNamespace);
SysFreeString (strNSNodeName);
}
pLocalNSPathNode->Release ();
}
pNodeList->Release ();
}
return hr;
}
// Parse an instance name
HRESULT ParseLocalInstancePathIntoNsAndInstName(IXMLDOMNode *pNode, BSTR *pstrNamespace, BSTR *pstrInstanceName)
{
HRESULT result = E_FAIL;
// See if the child is a KEYBINDING or KEYVALUE or KEYREFERENCE
IXMLDOMNode *pFirstNode, *pSecondNode = NULL;
if(SUCCEEDED(result = pNode->get_firstChild(&pFirstNode)) && pFirstNode)
{
// Get the Namespace part
if(SUCCEEDED(result = ParseLocalNamespacePath(pFirstNode, pstrNamespace)))
{
if(SUCCEEDED(result = pNode->get_lastChild(&pSecondNode)))
{
// Get the instance path
if(SUCCEEDED(result = ParseInstanceName(pSecondNode, pstrInstanceName)))
{
}
pSecondNode->Release();
}
if(FAILED(result))
{
SysFreeString(*pstrNamespace);
*pstrNamespace = NULL;
}
}
pFirstNode->Release();
}
return result;
}
// Takes an INSTANCEPATH node and gets its WMI object path representation
HRESULT ParseInstancePath (IXMLDOMNode *pNode, BSTR *pstrValue)
{
HRESULT hr = WBEM_E_FAILED;
// Expecting NAMESPACEPATH followed by INSTANCENAME
IXMLDOMNodeList *pNodeList = NULL;
if (pNode && SUCCEEDED(pNode->get_childNodes (&pNodeList)) && pNodeList)
{
IXMLDOMNode *pNSPathNode = NULL;
// Next node should be a NAMESPACEPATH
if (SUCCEEDED(pNodeList->nextNode (&pNSPathNode)) && pNSPathNode)
{
BSTR strNSNodeName = NULL;
if (SUCCEEDED(pNSPathNode->get_nodeName(&strNSNodeName)) &&
strNSNodeName && (_wcsicmp(strNSNodeName, NAMESPACEPATH_TAG) == 0))
{
BSTR strHost = NULL;
BSTR strNamespace = NULL;
if (SUCCEEDED (hr = ParseNamespacePath(pNSPathNode, &strHost, &strNamespace)))
{
// Next node should be the INSTANCENAME
IXMLDOMNode *pInstanceNameNode = NULL;
if (SUCCEEDED(pNodeList->nextNode (&pInstanceNameNode)) && pInstanceNameNode)
{
BSTR strNSInstanceName = NULL;
if (SUCCEEDED(pInstanceNameNode->get_nodeName(&strNSInstanceName)) &&
strNSInstanceName && (_wcsicmp(strNSInstanceName, INSTANCENAME_TAG) == 0))
{
BSTR strInstanceName = NULL;
if (SUCCEEDED(hr = ParseInstanceName (pInstanceNameNode,
&strInstanceName)))
{
// Phew - finally we have all the info!
LPWSTR pPath = NULL;
if(pPath = new WCHAR [wcslen(strHost)
+ wcslen(strNamespace) + wcslen(strInstanceName) + 5])
{
wcscpy (pPath, L"\\\\");
wcscat (pPath, strHost);
wcscat (pPath, L"\\");
wcscat (pPath, strNamespace);
wcscat (pPath, L":");
wcscat (pPath, strInstanceName);
*pstrValue = NULL;
if(*pstrValue = SysAllocString (pPath))
hr = S_OK;
else
hr = E_OUTOFMEMORY;
delete [] pPath;
}
else
hr = E_OUTOFMEMORY;
SysFreeString (strInstanceName);
}
SysFreeString (strNSInstanceName);
}
pInstanceNameNode->Release ();
}
SysFreeString (strHost);
SysFreeString (strNamespace);
}
SysFreeString (strNSNodeName);
}
pNSPathNode->Release ();
}
pNodeList->Release ();
}
return hr;
}
// Parse an class name
HRESULT ParseLocalClassPathAsNsAndClass(IXMLDOMNode *pNode, BSTR *pstrNamespace, BSTR *pstrClassPath)
{
HRESULT result = E_FAIL;
// See if the child is a KEYBINDING or KEYVALUE or KEYREFERENCE
IXMLDOMNode *pFirstNode, *pSecondNode = NULL;
if(SUCCEEDED(result = pNode->get_firstChild(&pFirstNode)) && pFirstNode)
{
// Get the Namespace part
if(SUCCEEDED(result = ParseLocalNamespacePath(pFirstNode, pstrNamespace)))
{
if(SUCCEEDED(result = pNode->get_lastChild(&pSecondNode)))
{
// Get the class name
if(SUCCEEDED(result = GetBstrAttribute(pSecondNode, NAME_ATTRIBUTE, pstrClassPath)))
{
}
pSecondNode->Release();
}
if(FAILED(result))
{
SysFreeString(*pstrNamespace);
*pstrNamespace = NULL;
}
}
pFirstNode->Release();
}
return result;
}
// Parse an instance path
HRESULT ParseInstancePath(IXMLDOMNode *pNode, BSTR *pstrHostName, BSTR *pstrNamespace, BSTR *pstrInstancePath)
{
HRESULT result = E_FAIL;
// Get the Namespacepath followed by the instance name
IXMLDOMNode *pFirstNode, *pSecondNode = NULL;
if(SUCCEEDED(result = pNode->get_firstChild(&pFirstNode)) && pFirstNode)
{
// Get the Namespace part
if(SUCCEEDED(result = ParseNamespacePath(pFirstNode, pstrHostName, pstrNamespace)))
{
if(SUCCEEDED(result = pNode->get_lastChild(&pSecondNode)))
{
// Get the instance path
if(SUCCEEDED(result = ParseInstanceName(pSecondNode, pstrInstancePath)))
{
}
pSecondNode->Release();
}
if(FAILED(result))
{
SysFreeString(*pstrHostName);
SysFreeString(*pstrNamespace);
*pstrHostName = NULL;
*pstrNamespace = NULL;
}
}
pFirstNode->Release();
}
return result;
}
// Parse a VALUE.ARRAY For now, assume that it's an array of strings
HRESULT ParseValueArray(IXMLDOMNode *pNode, BSTR **ppstrPropertyList, DWORD *pdwCount)
{
HRESULT result = E_FAIL;
*ppstrPropertyList = NULL;
// Go thru each of the VALUE nodes
//=======================================================
IXMLDOMNodeList *pList = NULL;
if(SUCCEEDED(result = pNode->get_childNodes(&pList)))
{
*pdwCount = 0;
long lCount = 0;
pList->get_length(&lCount);
*pdwCount = lCount;
// Allocate memory
if(*ppstrPropertyList = new BSTR [*pdwCount])
{
DWORD i=0;
IXMLDOMNode *pNextProperty = NULL;
while(SUCCEEDED(pList->nextNode(&pNextProperty)) && pNextProperty)
{
// Get the string in the VALUE
BSTR strNextName = NULL;
if(SUCCEEDED(ParseValue(pNextProperty,&((*ppstrPropertyList)[i]))))
{
}
else
ppstrPropertyList[i] = NULL;
pNextProperty->Release();
pNextProperty = NULL;
i++;
}
}
else
result = E_OUTOFMEMORY;
pList->Release();
}
return result;
}
// Parse PARAMVALUE.ARRAY in a propertylist
HRESULT ParsePropertyList(IXMLDOMNode *pNode, BSTR **ppstrPropertyList, DWORD *pdwCount)
{
// See if the child is a VALUE.ARRAY
HRESULT result = E_FAIL;
*ppstrPropertyList = NULL;
// Get the Namespacepath followed by the instance name
IXMLDOMNode *pFirstNode = NULL;
if(SUCCEEDED(result = pNode->get_firstChild(&pFirstNode)) && pFirstNode)
{
// THis should be a VALUE.ARRAY
if(SUCCEEDED(result = ParseValueArray(pFirstNode, ppstrPropertyList, pdwCount)))
{
}
pFirstNode->Release();
}
return result;
}
// Parse PARAMVALUE - the result is the child of this tag in ppValue and the name
// attribute of PARAMVALUE in ppszParamName
HRESULT ParseParamValue(IXMLDOMNode *pNode, BSTR *ppszParamName, IXMLDOMNode **ppValue)
{
HRESULT result = E_FAIL;
*ppValue = NULL;
// See if it has a child element which is
// (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY|VALUE.OBJECT|VALUE.OBJECTARRAY)
if(SUCCEEDED(result = pNode->get_firstChild(ppValue)) && (*ppValue))
{
BSTR strChildName = NULL;
if(SUCCEEDED(result = (*ppValue)->get_nodeName(&strChildName)))
{
if(_wcsicmp(strChildName, VALUE_TAG) == 0 ||
_wcsicmp(strChildName, VALUEARRAY_TAG) == 0 ||
_wcsicmp(strChildName, VALUEOBJECT_TAG) == 0 ||
_wcsicmp(strChildName, VALUEREFERENCE_TAG) == 0 ||
_wcsicmp(strChildName, VALUEOBJECTARRAY_TAG) == 0 ||
_wcsicmp(strChildName, VALUEREFARRAY_TAG) == 0 )
{
if(SUCCEEDED(result = GetBstrAttribute(pNode, NAME_ATTRIBUTE, ppszParamName)))
{
(*ppValue)->AddRef();
}
}
SysFreeString(strChildName);
}
(*ppValue)->Release();
}
if(FAILED(result) && (*ppValue))
{
(*ppValue)->Release();
*ppValue = NULL;
}
return result;
}
// Parse a PARAMVVALUE.INSTNAME
HRESULT ParseParamValueInstName(IXMLDOMNode *pNode, BSTR *pstrInstanceName)
{
HRESULT result = E_FAIL;
IXMLDOMNode *pChildNode = NULL;
if(SUCCEEDED(result = pNode->get_firstChild(&pChildNode)) && pChildNode)
{
result = ParseInstanceName(pChildNode, pstrInstanceName);
pChildNode->Release();
}
return result;
}
// Parse a Get Class request
CCimHttpGetClass * ParseGetClassMethod (
IXMLDOMNode *pNode,
BSTR strID)
{
CCimHttpGetClass *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a GetClass reques
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
// String values of the parameters
BSTR strLocalNamespace = NULL;
BSTR strClassName = NULL;
BSTR strLocalOnlyValue = NULL;
BSTR strIncludeQualifiers = NULL;
BSTR strIncludeClassOrigin = NULL;
BSTR *strPropertyList = NULL;
DWORD dwPropCount = 0;
// Set the optional parameters to their defaults
BOOLEAN bLocalsOnly = TRUE;
BOOLEAN bIncludeQualifiers = TRUE;
BOOLEAN bIncludeClassOrigin = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, CLASS_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strClassName);
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, LOCAL_ONLY_PARAM) == 0)
{
pNextParam->get_text(&strLocalOnlyValue);
}
else if(_wcsicmp(strParamName, INCLUDE_QUALIFIERS_PARAM) == 0)
{
pNextParam->get_text(&strIncludeQualifiers);
}
else if(_wcsicmp(strParamName, INCLUDE_CLASS_ORIGIN_PARAM) == 0)
{
pNextParam->get_text(&strIncludeClassOrigin);
}
else if(_wcsicmp(strParamName, PROPERTY_LIST_PARAM) == 0)
{
ParsePropertyList(pNextParam, &strPropertyList, &dwPropCount);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// Sort out the parameters created above
if(strLocalOnlyValue && _wcsicmp(strLocalOnlyValue, FALSE_WSTR) == 0)
bLocalsOnly = FALSE;
if(strIncludeQualifiers && _wcsicmp(strIncludeQualifiers, FALSE_WSTR) == 0)
bIncludeQualifiers = FALSE;
if(strIncludeClassOrigin && _wcsicmp(strIncludeClassOrigin, TRUE_WSTR) == 0)
bIncludeClassOrigin = TRUE;
// We only free those that are not needed
// The other pointers get copied by the contructor
SysFreeString(strLocalOnlyValue);
SysFreeString(strIncludeQualifiers);
SysFreeString(strIncludeClassOrigin);
pReturnValue = new CCimHttpGetClass(strClassName, strPropertyList, dwPropCount, bLocalsOnly, bIncludeQualifiers, bIncludeClassOrigin, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Create Class request
CCimHttpCreateClass * ParseCreateClassMethod (
IXMLDOMNode *pNode,
BSTR strID,
BOOLEAN bIsModify)
{
CCimHttpCreateClass *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
LONG lFlags = 0;
// Collect the list of parameters
//===============================
BSTR strLocalNamespace = NULL;
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
IXMLDOMNode *pClass = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if( 0 == _wcsicmp(strParamName, (bIsModify)? MODIFIED_CLASS_PARAM : NEW_CLASS_PARAM) )
{
// This should be a CLASS element
IXMLDOMNode *pPutativeClass = NULL;
if (SUCCEEDED (pNextParam->get_firstChild (&pPutativeClass)) && pPutativeClass)
{
BSTR strNodeName3 = NULL;
if (SUCCEEDED(pPutativeClass->get_nodeName
(&strNodeName3)))
{
if (_wcsicmp(strNodeName3, CLASS_TAG) == 0)
{
// Yowzer - we have it
pClass = pPutativeClass;
pClass->AddRef ();
}
SysFreeString (strNodeName3);
}
pPutativeClass->Release ();
}
}
else if( 0 == _wcsicmp(strParamName, LFLAGS_PARAM) )
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
ParseLongArgument (pParamValue, &lFlags);
pParamValue->Release ();
}
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpCreateClass(pClass, strLocalNamespace, strID,
bIsModify);
if(pClass)
pClass->Release();
if(pReturnValue)
{
pReturnValue->SetContextObject(pContextObject);
pReturnValue->SetFlags(lFlags);
}
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Create Instance request
CCimHttpCreateInstance * ParseCreateInstanceMethod (
IXMLDOMNode *pNode,
BSTR strID
)
{
CCimHttpCreateInstance *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a CreateInstance request
//============================================================
BSTR strLocalNamespace = NULL;
IXMLDOMNodeList *pParameters = NULL;
LONG lFlags = 0;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
IXMLDOMNode *pInstance = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, NEW_INSTANCE_PARAM) == 0)
{
// Should find a <INSTANCE> element now
IXMLDOMNode *pPutativeInstance = NULL;
if (SUCCEEDED (pNextParam->get_firstChild (&pPutativeInstance)) && pPutativeInstance)
{
BSTR strNodeName3 = NULL;
if (SUCCEEDED(pPutativeInstance->get_nodeName
(&strNodeName3)))
{
if (_wcsicmp(strNodeName3, INSTANCE_TAG) == 0)
{
// Yowzer - we have it
pInstance = pPutativeInstance;
pInstance->AddRef ();
}
SysFreeString (strNodeName3);
}
pPutativeInstance->Release ();
}
}
else if( 0 == _wcsicmp(strParamName, LFLAGS_PARAM) )
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
ParseLongArgument (pParamValue, &lFlags);
pParamValue->Release ();
}
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// We only free those that are not needed
// The other pointers get copied by the contructor
pReturnValue = new CCimHttpCreateInstance(pInstance, strLocalNamespace, strID);
if(pInstance)
pInstance->Release();
if(pReturnValue)
{
pReturnValue->SetContextObject(pContextObject);
pReturnValue->SetFlags(lFlags);
}
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Modify Instance request
CCimHttpModifyInstance * ParseModifyInstanceMethod (
IXMLDOMNode *pNode,
BSTR strID
)
{
CCimHttpModifyInstance *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a ModifyInstance request
//============================================================
BSTR strLocalNamespace = NULL;
IXMLDOMNodeList *pParameters = NULL;
BSTR strInstanceName = NULL;
LONG lFlags = 0;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
IXMLDOMNode *pInstance = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, MODIFIED_INSTANCE_PARAM) == 0)
{
// This should be a VALUE.NAMEDOBJECT element
IXMLDOMNode *pValue = NULL;
// RAJESHR must only be one node
if (SUCCEEDED (pNextParam->get_firstChild (&pValue)) && pValue)
{
BSTR strNodeName2 = NULL;
if(SUCCEEDED(pValue->get_nodeName(&strNodeName2)))
{
if(_wcsicmp(strNodeName2, VALUENAMEDOBJECT_TAG) == 0)
{
IXMLDOMNodeList *pInstNodeList = NULL;
if (SUCCEEDED(pValue->get_childNodes (&pInstNodeList)))
{
// Should find an <INSTANCENAME>
// and an <INSTANCE> element under here
IXMLDOMNode *pInstNameNode = NULL;
if (SUCCEEDED(pInstNodeList->nextNode (&pInstNameNode))
&& pInstNameNode)
{
BSTR instNameNode = NULL;
if(SUCCEEDED(pInstNameNode->get_nodeName(&instNameNode)))
{
if(_wcsicmp(instNameNode, INSTANCENAME_TAG) == 0)
{
// Parse into path
ParseInstanceName (pInstNameNode, &strInstanceName);
}
SysFreeString (instNameNode);
}
pInstNameNode->Release ();
}
if (SUCCEEDED (pInstNodeList->nextNode (&pInstance))
&& pInstance)
{
BSTR strInstanceNodeName = NULL;
if (SUCCEEDED(pInstance->get_nodeName
(&strInstanceNodeName)))
{
if (0 != _wcsicmp(strInstanceNodeName, INSTANCE_TAG))
{
// Error - get rid of it
pInstance->Release ();
pInstance = NULL;
}
SysFreeString (strInstanceNodeName);
}
else
{
// Error - get rid of it
pInstance->Release ();
pInstance = NULL;
}
}
pInstNodeList->Release ();
}
}
SysFreeString (strNodeName2);
}
pValue->Release ();
}
}
else if( 0 == _wcsicmp(strParamName, LFLAGS_PARAM) )
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
ParseLongArgument (pParamValue, &lFlags);
pParamValue->Release ();
}
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// We only free those that are not needed
// The other pointers get copied by the contructor
pReturnValue = new CCimHttpModifyInstance(pInstance, strInstanceName,
strLocalNamespace, strID);
if(pInstance)
pInstance->Release();
if(pReturnValue)
{
pReturnValue->SetContextObject(pContextObject);
pReturnValue->SetFlags(lFlags);
}
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Delete Class request
CCimHttpDeleteClass * ParseDeleteClassMethod (
IXMLDOMNode *pNode,
BSTR strID)
{
CCimHttpDeleteClass *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a DeleteClass reques
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
// String values of the parameters
BSTR strLocalNamespace = NULL;
BSTR strClassName = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, CLASS_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strClassName);
pParamValue->Release ();
}
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpDeleteClass(strClassName, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an EnumerateInstance request
CCimHttpEnumerateInstances * ParseEnumerateInstancesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpEnumerateInstances *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a Enumerate Instances request
//=================================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strClassName = NULL;
BSTR strLocalOnlyValue = NULL;
BSTR strDeepInheritanceValue = NULL;
BSTR strIncludeQualifiers = NULL;
BSTR strIncludeClassOrigin = NULL;
BSTR *strPropertyList = NULL;
DWORD dwPropCount = 0;
// Set the optional parameters to their defaults
BOOLEAN bLocalsOnly = TRUE;
BOOLEAN bDeepInheritance = TRUE;
BOOLEAN bIncludeQualifiers = FALSE;
BOOLEAN bIncludeClassOrigin = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, CLASS_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strClassName);
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, LOCAL_ONLY_PARAM) == 0)
{
pNextParam->get_text(&strLocalOnlyValue);
}
else if(_wcsicmp(strParamName, DEEP_INHERITANCE_PARAM) == 0)
{
pNextParam->get_text(&strDeepInheritanceValue);
}
else if(_wcsicmp(strParamName, INCLUDE_QUALIFIERS_PARAM) == 0)
{
pNextParam->get_text(&strIncludeQualifiers);
}
else if(_wcsicmp(strParamName, INCLUDE_CLASS_ORIGIN_PARAM) == 0)
{
pNextParam->get_text(&strIncludeClassOrigin);
}
else if(_wcsicmp(strParamName, PROPERTY_LIST_PARAM) == 0)
{
ParsePropertyList(pNextParam, &strPropertyList, &dwPropCount);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// Sort out the parameters created above
if(strLocalOnlyValue && _wcsicmp(strLocalOnlyValue, FALSE_WSTR) == 0)
bLocalsOnly = FALSE;
if(strDeepInheritanceValue && _wcsicmp(strDeepInheritanceValue, FALSE_WSTR) == 0)
bDeepInheritance = FALSE;
if(strIncludeQualifiers && _wcsicmp(strIncludeQualifiers, TRUE_WSTR) == 0)
bIncludeQualifiers = TRUE;
if(strIncludeClassOrigin && _wcsicmp(strIncludeClassOrigin, TRUE_WSTR) == 0)
bIncludeClassOrigin = TRUE;
SysFreeString(strLocalOnlyValue);
SysFreeString(strIncludeQualifiers);
SysFreeString(strIncludeClassOrigin);
SysFreeString(strDeepInheritanceValue);
pReturnValue = new CCimHttpEnumerateInstances(strClassName, strPropertyList, dwPropCount, bDeepInheritance, bLocalsOnly, bIncludeQualifiers, bIncludeClassOrigin, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an EnumerateInstanceNames request
CCimHttpEnumerateInstanceNames * ParseEnumerateInstanceNamesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpEnumerateInstanceNames *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a Enumerate InstanceNames request
//=====================================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strClassName = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, CLASS_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strClassName);
pParamValue->Release ();
}
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpEnumerateInstanceNames(strClassName, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an EnumerateClasses request
CCimHttpEnumerateClasses * ParseEnumerateClassesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpEnumerateClasses *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a Enumerate Instances request
//=================================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strClassName = NULL;
BSTR strLocalOnlyValue = NULL;
BSTR strDeepInheritanceValue = NULL;
BSTR strIncludeQualifiers = NULL;
BSTR strIncludeClassOrigin = NULL;
BSTR *strPropertyList = NULL;
DWORD dwPropCount = 0;
// Set the optional parameters to their defaults
BOOLEAN bLocalsOnly = TRUE;
BOOLEAN bDeepInheritance = TRUE;
BOOLEAN bIncludeQualifiers = FALSE;
BOOLEAN bIncludeClassOrigin = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, CLASS_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strClassName);
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, LOCAL_ONLY_PARAM) == 0)
{
pNextParam->get_text(&strLocalOnlyValue);
}
else if(_wcsicmp(strParamName, DEEP_INHERITANCE_PARAM) == 0)
{
pNextParam->get_text(&strDeepInheritanceValue);
}
else if(_wcsicmp(strParamName, INCLUDE_QUALIFIERS_PARAM) == 0)
{
pNextParam->get_text(&strIncludeQualifiers);
}
else if(_wcsicmp(strParamName, INCLUDE_CLASS_ORIGIN_PARAM) == 0)
{
pNextParam->get_text(&strIncludeClassOrigin);
}
else if(_wcsicmp(strParamName, PROPERTY_LIST_PARAM) == 0)
{
ParsePropertyList(pNextParam, &strPropertyList, &dwPropCount);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// Sort out the parameters created above
if(strLocalOnlyValue && _wcsicmp(strLocalOnlyValue, FALSE_WSTR) == 0)
bLocalsOnly = FALSE;
if(strDeepInheritanceValue && _wcsicmp(strDeepInheritanceValue, FALSE_WSTR) == 0)
bDeepInheritance = FALSE;
if(strIncludeQualifiers && _wcsicmp(strIncludeQualifiers, TRUE_WSTR) == 0)
bIncludeQualifiers = TRUE;
if(strIncludeClassOrigin && _wcsicmp(strIncludeClassOrigin, TRUE_WSTR) == 0)
bIncludeClassOrigin = TRUE;
SysFreeString(strLocalOnlyValue);
SysFreeString(strIncludeQualifiers);
SysFreeString(strIncludeClassOrigin);
SysFreeString(strDeepInheritanceValue);
pReturnValue = new CCimHttpEnumerateClasses(strClassName, strPropertyList, dwPropCount, bDeepInheritance, bLocalsOnly, bIncludeQualifiers, bIncludeClassOrigin, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an EnumerateClassNames request
CCimHttpEnumerateClassNames * ParseEnumerateClassNamesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpEnumerateClassNames *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a EnumerateClassNames request
//=================================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strClassName = NULL;
BSTR strDeepInheritanceValue = NULL;
BOOLEAN bDeepInheritance = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, CLASS_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strClassName);
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, DEEP_INHERITANCE_PARAM) == 0)
{
pNextParam->get_text(&strDeepInheritanceValue);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
if(strDeepInheritanceValue && _wcsicmp(strDeepInheritanceValue, TRUE_WSTR) == 0)
bDeepInheritance = TRUE;
SysFreeString(strDeepInheritanceValue);
pReturnValue = new CCimHttpEnumerateClassNames(strClassName, strLocalNamespace,
bDeepInheritance, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Get Instance request
CCimHttpGetInstance * ParseGetInstanceMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpGetInstance *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a GetInstance reques
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strInstanceName = NULL;
BSTR strLocalOnlyValue = NULL;
BSTR strIncludeQualifiers = NULL;
BSTR strIncludeClassOrigin = NULL;
BSTR *strPropertyList = NULL;
DWORD dwPropCount = 0;
// Set the optional parameters to their defaults
BOOLEAN bLocalsOnly = TRUE;
BOOLEAN bIncludeQualifiers = FALSE;
BOOLEAN bIncludeClassOrigin = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, LOCAL_ONLY_PARAM) == 0)
{
pNextParam->get_text(&strLocalOnlyValue);
}
else if(_wcsicmp(strParamName, INCLUDE_QUALIFIERS_PARAM) == 0)
{
pNextParam->get_text(&strIncludeQualifiers);
}
else if(_wcsicmp(strParamName, INCLUDE_CLASS_ORIGIN_PARAM) == 0)
{
pNextParam->get_text(&strIncludeClassOrigin);
}
if(_wcsicmp(strParamName, INSTANCE_NAME_PARAM) == 0)
{
ParseParamValueInstName(pNextParam, &strInstanceName);
}
else if(_wcsicmp(strParamName, PROPERTY_LIST_PARAM) == 0)
{
ParsePropertyList(pNextParam, &strPropertyList, &dwPropCount);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// Sort out the parameters created above
if(strLocalOnlyValue && _wcsicmp(strLocalOnlyValue, FALSE_WSTR) == 0)
bLocalsOnly = FALSE;
if(strIncludeQualifiers && _wcsicmp(strIncludeQualifiers, TRUE_WSTR) == 0)
bIncludeQualifiers = TRUE;
if(strIncludeClassOrigin && _wcsicmp(strIncludeClassOrigin, TRUE_WSTR) == 0)
bIncludeClassOrigin = TRUE;
SysFreeString(strLocalOnlyValue);
SysFreeString(strIncludeQualifiers);
SysFreeString(strIncludeClassOrigin);
pReturnValue = new CCimHttpGetInstance(strInstanceName, strPropertyList, dwPropCount,
bLocalsOnly, bIncludeQualifiers, bIncludeClassOrigin, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Delete Instance request
CCimHttpDeleteInstance * ParseDeleteInstanceMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpDeleteInstance *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a DeleteInstance request
//============================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strInstanceName = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
ParseParamValueInstName(pNextParam, &strInstanceName);
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpDeleteInstance(strInstanceName, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Get Class request
CCimHttpExecQuery * ParseExecQueryMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpExecQuery *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a GetClass reques
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strQuery = NULL;
BSTR strQueryLanguage = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// Process the parameter
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, QUERY_LANGUAGE_PARAM) == 0)
{
pNextParam->get_text(&strQueryLanguage);
}
else if(_wcsicmp(strParamName, QUERY_PARAM) == 0)
{
pNextParam->get_text(&strQuery);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpExecQuery(strQuery, strQueryLanguage, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Get Property request
CCimHttpGetProperty * ParseGetPropertyMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpGetProperty *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a GetInstance reques
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strInstanceName = NULL;
BSTR strPropertyName = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, PROPERTY_NAME_PARAM) == 0)
{
pNextParam->get_text(&strPropertyName);
}
else if(_wcsicmp(strParamName, INSTANCE_NAME_PARAM) == 0)
{
ParseParamValueInstName(pNextParam, &strInstanceName);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpGetProperty(strInstanceName, strPropertyName, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a Set Property request
CCimHttpSetProperty * ParseSetPropertyMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpSetProperty *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a GetInstance reques
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strInstanceName = NULL;
BSTR strPropertyName = NULL;
IXMLDOMNode *pPropertyValue = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, PROPERTY_NAME_PARAM) == 0)
{
pNextParam->get_text(&strPropertyName);
}
else if(_wcsicmp(strParamName, INSTANCE_NAME_PARAM) == 0)
{
ParseParamValueInstName(pNextParam, &strInstanceName);
}
else if(_wcsicmp(strParamName, NEW_VALUE_PARAM) == 0)
{
pNextParam->get_firstChild (&pPropertyValue);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpSetProperty(strInstanceName, strPropertyName,
pPropertyValue, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
if (pPropertyValue)
pPropertyValue->Release ();
pParameters->Release();
}
return pReturnValue;
}
// Parse an Associators request
CCimHttpAssociators * ParseAssociatorsMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpAssociators *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a Enumerate Instances request
//=================================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strObjectName = NULL;
BSTR strAssocClass = NULL;
BSTR strResultClass = NULL;
BSTR strRole = NULL;
BSTR strResultRole = NULL;
BSTR strIncludeQualifiers = NULL;
BSTR strIncludeClassOrigin = NULL;
BSTR *strPropertyList = NULL;
DWORD dwPropCount = 0;
// Set the optional parameters to their defaults
BOOLEAN bIncludeQualifiers = FALSE;
BOOLEAN bIncludeClassOrigin = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, OBJECT_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
// RAJESHR should only be one child
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
BSTR strNodeName2 = NULL;
// CLASSNAME or INSTANCENAME expect
if (SUCCEEDED (pParamValue->get_nodeName (&strNodeName2)))
{
if (_wcsicmp(strNodeName2, CLASS_NAME_PARAM) == 0)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strObjectName);
}
else if (_wcsicmp(strNodeName2, INSTANCE_NAME_PARAM) == 0)
{
ParseInstanceName (pParamValue, &strObjectName);
}
SysFreeString (strNodeName2);
}
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, INCLUDE_QUALIFIERS_PARAM) == 0)
{
pNextParam->get_text(&strIncludeQualifiers);
}
else if(_wcsicmp(strParamName, INCLUDE_CLASS_ORIGIN_PARAM) == 0)
{
pNextParam->get_text(&strIncludeClassOrigin);
}
else if(_wcsicmp(strParamName, ASSOC_CLASS_PARAM) == 0)
{
pNextParam->get_text(&strAssocClass);
}
else if(_wcsicmp(strParamName, RESULT_CLASS_PARAM) == 0)
{
pNextParam->get_text(&strResultClass);
}
else if(_wcsicmp(strParamName, ROLE_PARAM) == 0)
{
pNextParam->get_text(&strRole);
}
else if(_wcsicmp(strParamName, RESULT_ROLE_PARAM) == 0)
{
pNextParam->get_text(&strResultRole);
}
else if(_wcsicmp(strParamName, PROPERTY_LIST_PARAM) == 0)
{
ParsePropertyList(pNextParam, &strPropertyList, &dwPropCount);
}
SysFreeString(strParamName);
}
else
{
// A nameless parameter - just ignore it since
// we're doing loose validation
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// Sort out the parameters created above
if(strIncludeQualifiers && _wcsicmp(strIncludeQualifiers, TRUE_WSTR) == 0)
bIncludeQualifiers = TRUE;
if(strIncludeClassOrigin && _wcsicmp(strIncludeClassOrigin, TRUE_WSTR) == 0)
bIncludeClassOrigin = TRUE;
SysFreeString(strIncludeQualifiers);
SysFreeString(strIncludeClassOrigin);
pReturnValue = new CCimHttpAssociators(strObjectName, strPropertyList, dwPropCount, bIncludeQualifiers, bIncludeClassOrigin,
strAssocClass, strResultClass, strRole, strResultRole, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an AssociatorNames request
CCimHttpAssociatorNames * ParseAssociatorNamesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpAssociatorNames *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters for a Enumerate Instances request
//=================================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strObjectName = NULL;
BSTR strAssocClass = NULL;
BSTR strResultClass = NULL;
BSTR strRole = NULL;
BSTR strResultRole = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, OBJECT_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
// RAJESHR should only be one child
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
BSTR strNodeName2 = NULL;
// CLASSNAME or INSTANCENAME expect
if (SUCCEEDED (pParamValue->get_nodeName (&strNodeName2)))
{
if (_wcsicmp(strNodeName2, CLASS_NAME_PARAM) == 0)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strObjectName);
}
else if (_wcsicmp(strNodeName2, INSTANCE_NAME_PARAM) == 0)
{
ParseInstanceName (pParamValue, &strObjectName);
}
SysFreeString (strNodeName2);
}
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, ASSOC_CLASS_PARAM) == 0)
{
pNextParam->get_text(&strAssocClass);
}
else if(_wcsicmp(strParamName, RESULT_CLASS_PARAM) == 0)
{
pNextParam->get_text(&strResultClass);
}
else if(_wcsicmp(strParamName, ROLE_PARAM) == 0)
{
pNextParam->get_text(&strRole);
}
else if(_wcsicmp(strParamName, RESULT_ROLE_PARAM) == 0)
{
pNextParam->get_text(&strResultRole);
}
SysFreeString(strParamName);
}
else
{
// A nameless parameter - just ignore it since
// we're doing loose validation
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpAssociatorNames(strObjectName,
strAssocClass, strResultClass, strRole,
strResultRole, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an Refrerences request
CCimHttpReferences * ParseReferencesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpReferences *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters
//===============================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strObjectName = NULL;
BSTR strRole = NULL;
BSTR strResultClass = NULL;
BSTR strIncludeQualifiers = NULL;
BSTR strIncludeClassOrigin = NULL;
BSTR *strPropertyList = NULL;
DWORD dwPropCount = 0;
// Set the optional parameters to their defaults
BOOLEAN bIncludeQualifiers = FALSE;
BOOLEAN bIncludeClassOrigin = FALSE;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, OBJECT_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
// RAJESHR should only be one child
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
BSTR strNodeName2 = NULL;
// CLASSNAME or INSTANCENAME expect
if (SUCCEEDED (pParamValue->get_nodeName (&strNodeName2)))
{
if (_wcsicmp(strNodeName2, CLASS_NAME_PARAM) == 0)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strObjectName);
}
else if (_wcsicmp(strNodeName2, INSTANCE_NAME_PARAM) == 0)
{
ParseInstanceName (pParamValue, &strObjectName);
}
SysFreeString (strNodeName2);
}
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, INCLUDE_QUALIFIERS_PARAM) == 0)
{
pNextParam->get_text(&strIncludeQualifiers);
}
else if(_wcsicmp(strParamName, INCLUDE_CLASS_ORIGIN_PARAM) == 0)
{
pNextParam->get_text(&strIncludeClassOrigin);
}
else if(_wcsicmp(strParamName, ROLE_PARAM) == 0)
{
pNextParam->get_text(&strRole);
}
else if(_wcsicmp(strParamName, RESULT_CLASS_PARAM) == 0)
{
pNextParam->get_text(&strResultClass);
}
else if(_wcsicmp(strParamName, PROPERTY_LIST_PARAM) == 0)
{
ParsePropertyList(pNextParam, &strPropertyList, &dwPropCount);
}
SysFreeString(strParamName);
}
else
{
// A nameless parameter - just ignore it since
// we're doing loose validation
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
// Sort out the parameters created above
if(strIncludeQualifiers && _wcsicmp(strIncludeQualifiers, TRUE_WSTR) == 0)
bIncludeQualifiers = TRUE;
if(strIncludeClassOrigin && _wcsicmp(strIncludeClassOrigin, TRUE_WSTR) == 0)
bIncludeClassOrigin = TRUE;
SysFreeString(strIncludeQualifiers);
SysFreeString(strIncludeClassOrigin);
pReturnValue = new CCimHttpReferences(strObjectName, strPropertyList,
dwPropCount, bIncludeQualifiers, bIncludeClassOrigin,
strResultClass, strRole, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse an ReferenceNames request
CCimHttpReferenceNames * ParseReferenceNamesMethod(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpReferenceNames *pReturnValue = NULL;
IXMLDOMNode *pContextObject = NULL;
// Collect the list of parameters
//===============================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
BSTR strLocalNamespace = NULL;
BSTR strObjectName = NULL;
BSTR strRole = NULL;
BSTR strResultClass = NULL;
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
// We dont want to process the LOCALNAMESPACEPATH child node in this loop, only params
if(_wcsicmp(strNodeName, IPARAMVALUE_TAG) == 0)
{
BSTR strParamName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNextParam, NAME_ATTRIBUTE, &strParamName)))
{
if(_wcsicmp(strParamName, OBJECT_NAME_PARAM) == 0)
{
IXMLDOMNode *pParamValue = NULL;
// RAJESHR should only be one child
if (SUCCEEDED(pNextParam->get_firstChild (&pParamValue)) && pParamValue)
{
BSTR strNodeName2 = NULL;
// CLASSNAME or INSTANCENAME expect
if (SUCCEEDED (pParamValue->get_nodeName (&strNodeName2)))
{
if (_wcsicmp(strNodeName2, CLASS_NAME_PARAM) == 0)
{
GetBstrAttribute (pParamValue, NAME_ATTRIBUTE, &strObjectName);
}
else if (_wcsicmp(strNodeName2, INSTANCE_NAME_PARAM) == 0)
{
ParseInstanceName (pParamValue, &strObjectName);
}
SysFreeString (strNodeName2);
}
pParamValue->Release ();
}
}
else if(_wcsicmp(strParamName, ROLE_PARAM) == 0)
{
pNextParam->get_text(&strRole);
}
else if(_wcsicmp(strParamName, RESULT_CLASS_PARAM) == 0)
{
pNextParam->get_text(&strResultClass);
}
SysFreeString(strParamName);
}
}
else if(_wcsicmp(strNodeName, LOCALNAMESPACEPATH_TAG) == 0)
{
ParseLocalNamespacePath(pNextParam, &strLocalNamespace);
}
else if(_wcsicmp(strNodeName, CONTEXTOBJECT_TAG) == 0)
{
pContextObject = pNextParam;pContextObject->AddRef();
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pReturnValue = new CCimHttpReferenceNames(strObjectName,
strResultClass, strRole, strLocalNamespace, strID);
if(pReturnValue)
pReturnValue->SetContextObject(pContextObject);
if(pContextObject)
pContextObject->Release();
pParameters->Release();
}
return pReturnValue;
}
// Parse a IMETHODCALL element
CCimHttpMessage * ParseIMethodCall(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpMessage *pReturnValue = NULL;
bool bIsWhistlerMethod = false;
// See if it is a Whistler Method
BSTR strWMIWhistlerMethod = NULL;
if(SUCCEEDED(GetBstrAttribute(pNode, WMI_ATTRIBUTE, &strWMIWhistlerMethod)))
{
SysFreeString(strWMIWhistlerMethod);
bIsWhistlerMethod = true;
}
BSTR strMethodName = NULL;
if(SUCCEEDED(GetBstrAttribute(pNode, NAME_ATTRIBUTE, &strMethodName)))
{
#ifdef WMI_XML_WHISTLER
if(bIsWhistlerMethod)
{
if(_wcsicmp(strMethodName, GET_OBJECT_METHOD) == 0)
pReturnValue = new CCimWhistlerGetObjectMethod(pNode, strID);
else if(_wcsicmp(strMethodName, ENUMERATE_INSTANCES_METHOD) == 0)
pReturnValue = new CCimWhistlerEnumerateInstancesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, EXEC_QUERY_METHOD) == 0)
pReturnValue = new CCimWhistlerExecQueryMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ENUMERATE_CLASSES_METHOD) == 0)
pReturnValue = new CCimWhistlerEnumerateClassesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, DELETE_CLASS_METHOD) == 0)
pReturnValue = new CCimWhistlerDeleteClassMethod(pNode, strID);
else if (_wcsicmp(strMethodName, DELETE_INSTANCE_METHOD) == 0)
pReturnValue = new CCimWhistlerDeleteInstanceMethod(pNode, strID);
else if (_wcsicmp(strMethodName, CREATE_CLASS_METHOD) == 0)
pReturnValue = new CCimWhistlerCreateClassMethod(pNode, strID);
else if (_wcsicmp(strMethodName, CREATE_INSTANCE_METHOD) == 0)
pReturnValue = new CCimWhistlerCreateInstanceMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ADD_METHOD) == 0)
pReturnValue = new CCimWhistlerAddMethod(pNode, strID);
else if (_wcsicmp(strMethodName, REMOVE_METHOD) == 0)
pReturnValue = new CCimWhistlerRemoveMethod(pNode, strID);
else if (_wcsicmp(strMethodName, RENAME_METHOD) == 0)
pReturnValue = new CCimWhistlerRenameMethod(pNode, strID);
else if (_wcsicmp(strMethodName, GET_OBJECT_SECURITY_METHOD) == 0)
pReturnValue = new CCimWhistlerGetObjectSecurityMethod(pNode, strID);
else if (_wcsicmp(strMethodName, PUT_OBJECT_SECURITY_METHOD) == 0)
pReturnValue = new CCimWhistlerPutObjectSecurityMethod(pNode, strID);
}
else
#endif
{
if(_wcsicmp(strMethodName, GET_CLASS_METHOD) == 0)
pReturnValue = ParseGetClassMethod(pNode, strID);
else if(_wcsicmp(strMethodName, ENUMERATE_INSTANCES_METHOD) == 0)
pReturnValue = ParseEnumerateInstancesMethod(pNode, strID);
else if(_wcsicmp(strMethodName, GET_INSTANCE_METHOD) == 0)
pReturnValue = ParseGetInstanceMethod(pNode, strID);
else if (_wcsicmp(strMethodName, EXEC_QUERY_METHOD) == 0)
pReturnValue = ParseExecQueryMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ENUMERATE_INSTANCENAMES_METHOD) == 0)
pReturnValue = ParseEnumerateInstanceNamesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ENUMERATE_CLASSES_METHOD) == 0)
pReturnValue = ParseEnumerateClassesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ENUMERATE_CLASSNAMES_METHOD) == 0)
pReturnValue = ParseEnumerateClassNamesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, GET_PROPERTY_METHOD) == 0)
pReturnValue = ParseGetPropertyMethod(pNode, strID);
else if (_wcsicmp(strMethodName, SET_PROPERTY_METHOD) == 0)
pReturnValue = ParseSetPropertyMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ASSOCIATORS_METHOD) == 0)
pReturnValue = ParseAssociatorsMethod(pNode, strID);
else if (_wcsicmp(strMethodName, ASSOCIATOR_NAMES_METHOD) == 0)
pReturnValue = ParseAssociatorNamesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, REFERENCES_METHOD) == 0)
pReturnValue = ParseReferencesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, REFERENCE_NAMES_METHOD) == 0)
pReturnValue = ParseReferenceNamesMethod(pNode, strID);
else if (_wcsicmp(strMethodName, DELETE_CLASS_METHOD) == 0)
pReturnValue = ParseDeleteClassMethod(pNode, strID);
else if (_wcsicmp(strMethodName, DELETE_INSTANCE_METHOD) == 0)
pReturnValue = ParseDeleteInstanceMethod(pNode, strID);
else if (_wcsicmp(strMethodName, CREATE_CLASS_METHOD) == 0)
pReturnValue = ParseCreateClassMethod(pNode, strID, FALSE);
else if (_wcsicmp(strMethodName, CREATE_INSTANCE_METHOD) == 0)
pReturnValue = ParseCreateInstanceMethod(pNode, strID);
else if (_wcsicmp(strMethodName, MODIFY_CLASS_METHOD) == 0)
pReturnValue = ParseCreateClassMethod(pNode, strID, TRUE);
else if (_wcsicmp(strMethodName, MODIFY_INSTANCE_METHOD) == 0)
pReturnValue = ParseModifyInstanceMethod(pNode, strID);
}
SysFreeString(strMethodName);
}
return pReturnValue;
}
// Parse a METHODCALL element
CCimHttpMessage * ParseMethodCall(IXMLDOMNode *pNode, BSTR strID)
{
CCimHttpMethod *pReturnValue = NULL;
BSTR strMethodName = NULL;
CParameterMap *pParameterMap = NULL;
BSTR strNamespace = NULL;
BSTR strObjectPath = NULL;
if(pParameterMap = new CParameterMap())
{
// Get the Method Name
if(SUCCEEDED(GetBstrAttribute(pNode, NAME_ATTRIBUTE, &strMethodName)))
{
// Collect the list of parameters for a request
//=======================================================
IXMLDOMNodeList *pParameters = NULL;
if(SUCCEEDED(pNode->get_childNodes(&pParameters)))
{
IXMLDOMNode *pNextParam = NULL;
while(SUCCEEDED(pParameters->nextNode(&pNextParam)) && pNextParam)
{
// Get its name
BSTR strNodeName = NULL;
if(SUCCEEDED(pNextParam->get_nodeName(&strNodeName)))
{
if(_wcsicmp(strNodeName, LOCALINSTANCEPATH_TAG) == 0)
{
ParseLocalInstancePathIntoNsAndInstName(pNextParam, &strNamespace, &strObjectPath);
pReturnValue = new CCimHttpMethod(strMethodName, FALSE, strNamespace, strObjectPath, strID);
}
else if(_wcsicmp(strNodeName, LOCALCLASSPATH_TAG) == 0)
{
ParseLocalClassPathAsNsAndClass(pNextParam, &strNamespace, &strObjectPath);
pReturnValue = new CCimHttpMethod(strMethodName, TRUE, strNamespace, strObjectPath, strID);
}
else if(_wcsicmp(strNodeName, PARAMVALUE_TAG) == 0)
{
IXMLDOMNode *pParameterValue = NULL;
BSTR strParamName = NULL;
if(SUCCEEDED(ParseParamValue(pNextParam, &strParamName, &pParameterValue)) && pParameterValue && strParamName)
pParameterMap->SetAt(strParamName, pParameterValue);
// No need to release pParameterValue.
// It gets released when the parameter map is destroyed
}
SysFreeString(strNodeName);
}
pNextParam->Release();
pNextParam = NULL;
}
pParameters->Release();
}
}
}
if(pReturnValue)
{
pReturnValue->SetInputParameters(pParameterMap);
}
else
{
if(pParameterMap)
CCimHttpMethod::DestroyParameterMap(pParameterMap);
delete pParameterMap;
SysFreeString(strNamespace);
SysFreeString(strObjectPath);
}
return pReturnValue;
}
// Parse a SIMPLEREQ element
CCimHttpMessage * ParseSimpleReq(IXMLDOMNode *pNode, BSTR strID, BOOLEAN bIsMpostRequest, BOOLEAN bIsMicrosoftWMIClient, WMI_XML_HTTP_VERSION iHttpVersion)
{
CCimHttpMessage *pReturnValue = NULL;
// See if the child is an METHODCALL or IMETHODCALL
IXMLDOMNode *pMethodNode = NULL;
if(SUCCEEDED(pNode->get_firstChild(&pMethodNode)) && pMethodNode)
{
BSTR strNodeName = NULL;
if(SUCCEEDED(pMethodNode->get_nodeName(&strNodeName)))
{
if(_wcsicmp(strNodeName, IMETHODCALL_TAG) == 0)
{
pReturnValue = ParseIMethodCall(pMethodNode, strID);
}
else if(_wcsicmp(strNodeName, METHODCALL_TAG) == 0)
{
pReturnValue = ParseMethodCall(pMethodNode, strID);
}
SysFreeString(strNodeName);
}
pMethodNode->Release();
}
if (pReturnValue)
{
pReturnValue->SetIsMpost (bIsMpostRequest);
pReturnValue->SetHttpVersion(iHttpVersion);
pReturnValue->SetMicrosoftClient(bIsMicrosoftWMIClient);
}
return pReturnValue;
}
// Parse a MULTIREQ element
BOOLEAN ParseMultiReq(IXMLDOMNodeList *pReqList, CCimHttpMultiMessage *pMultiRequest, BSTR strID, BOOLEAN bIsMpostRequest, BOOLEAN bIsMicrosoftWMIClient, WMI_XML_HTTP_VERSION iHttpVersion, DWORD dwNumSimpleRequests)
{
pMultiRequest->SetHttpVersion(iHttpVersion);
pMultiRequest->SetMicrosoftClient(bIsMicrosoftWMIClient);
// Allocate an array of pointers
//===============================
CCimHttpMessage **ppSimpleMessages = NULL;
if(ppSimpleMessages = new CCimHttpMessage *[dwNumSimpleRequests])
{
// Initialize each of the pointers in the above array with a simple request object
//================================================================================
IXMLDOMNode *pSimpleReqNode = NULL;
DWORD dwSimpleRequestCount = 0;
BOOLEAN bAllSubNodesParsed = TRUE;
CCimHttpMessage *pNextSimpleRequest = NULL;
while (SUCCEEDED(pReqList->nextNode (&pSimpleReqNode))
&& pSimpleReqNode && bAllSubNodesParsed)
{
// Parse the next simple request
ppSimpleMessages[dwSimpleRequestCount] = NULL;
if(ppSimpleMessages[dwSimpleRequestCount] = ParseSimpleReq(pSimpleReqNode, strID, bIsMpostRequest, bIsMicrosoftWMIClient, iHttpVersion))
{
dwSimpleRequestCount ++;
}
else
{
bAllSubNodesParsed = FALSE;
}
pSimpleReqNode->Release ();
pSimpleReqNode = NULL;
pNextSimpleRequest = NULL;
}
if(bAllSubNodesParsed)
{
// Set the MultiRequest object with this array of SimpleRequest objects
pMultiRequest->SetSimpleRequests(ppSimpleMessages, dwNumSimpleRequests);
return TRUE;
}
else // Deallocate all memory
{
for(DWORD i=0; i<dwSimpleRequestCount; i++)
delete ppSimpleMessages[i];
delete [] ppSimpleMessages;
}
}
return FALSE;
}
//***************************************************************************
//
// BOOLEAN ParseXMLIntoCIMOperation
//
// Description:
//
// Take the XML Document describing the request and execute the
// corresponding WMI operations.
//
// Parameters:
//
// pMessageNode Pointer to the MESSAGE element
// ppReturnObject Holds response message
// pdwStatus Holds HTTP response status on return
// bIsMpostRequest Whether this is M-POST or POST
// bIsMicrosoftWMIClient Whether this is a Microsoft CLient (i.e, the bIsMicrosoftWMIClient header was set)
//
// Return Value:
//
// TRUE if operation executed, FALSE otherwise
//
//***************************************************************************
BOOLEAN ParseXMLIntoCIMOperation(
IXMLDOMNode *pMessageNode,
CCimHttpMessage **ppReturnObject,
DWORD *pdwStatus,
BOOLEAN bIsMpostRequest,
BOOLEAN bIsMicrosoftWMIClient,
WMI_XML_HTTP_VERSION iHttpVersion,
LPSTR *ppszCimError)
{
*ppReturnObject = NULL;
*pdwStatus = 400; // Bad Request by default
*ppszCimError = NULL;
BSTR strIDValue = NULL;
// Get the ProtocolVersion attribute from the MESSAGE element
BSTR bsProtocolVersion = NULL;
if(SUCCEEDED(GetBstrAttribute(pMessageNode, PROTOVERSION_ATTRIBUTE, &bsProtocolVersion)))
{
if (!bsProtocolVersion || (0 != wcscmp (bsProtocolVersion, L"1.0")))
{
*pdwStatus = 501;
*ppszCimError = CIM_UNSUPPORTED_PROTOCOL_VERSION;
}
else
{
// We need its ID attribute
if(SUCCEEDED(GetBstrAttribute(pMessageNode, ID_ATTRIBUTE, &strIDValue)) && strIDValue)
{
// Look for (MULTIREQ|SIMPLEREQ)
IXMLDOMNodeList *pNodeList = NULL;
if (SUCCEEDED(pMessageNode->get_childNodes (&pNodeList)) && pNodeList)
{
// Before we execute anything, check that we have a correct document
// of the form (MULTIREQ|SIMPLEREQ)
IXMLDOMNode *pRequestNode = NULL;
IXMLDOMNode *pCurNode = NULL;
BOOLEAN bFoundReq = FALSE;
BOOLEAN bError = FALSE;
BOOLEAN bIsMultiReq = FALSE;
// Get the Simple or Multi Request Node
//========================================
while (!bFoundReq && SUCCEEDED(pNodeList->nextNode (&pCurNode)) && pCurNode)
{
BSTR bsNodeName = NULL;
if (SUCCEEDED(pCurNode->get_nodeName(&bsNodeName)))
{
if (0 == _wcsicmp(bsNodeName, MULTIREQ_TAG))
{
pRequestNode = pCurNode;
pRequestNode->AddRef ();
bIsMultiReq = TRUE;
bFoundReq = TRUE;
}
else if (0 == _wcsicmp(bsNodeName, SIMPLEREQ_TAG))
{
pRequestNode = pCurNode;
pRequestNode->AddRef ();
bFoundReq = TRUE;
}
SysFreeString (bsNodeName);
}
pCurNode->Release ();
pCurNode = NULL;
}
if (bFoundReq)
{
if (bIsMultiReq)
{
// Create a MULTIREQ object
//============================
IXMLDOMNodeList *pReqList = NULL;
if (SUCCEEDED(pRequestNode->get_childNodes (&pReqList)) && pReqList)
{
// Pass 1 - Count the number of SIMPLEREQ elements in the multi request
// We do loose validation
IXMLDOMNode *pSimpleReqNode = NULL;
DWORD dwSimpleReqCount = 0;
while (SUCCEEDED(pReqList->nextNode (&pSimpleReqNode)) && pSimpleReqNode)
{
BSTR bsReqNodeName = NULL;
if (SUCCEEDED(pSimpleReqNode->get_nodeName(&bsReqNodeName)))
{
if (0 == _wcsicmp(bsReqNodeName, SIMPLEREQ_TAG))
dwSimpleReqCount++;
SysFreeString (bsReqNodeName);
}
pSimpleReqNode->Release ();
pSimpleReqNode = NULL;
}
// Pass 2 - now create a MULTIREQ object
if (SUCCEEDED(pReqList->reset()))
{
if(*ppReturnObject = new
CCimHttpMultiMessage (strIDValue, bIsMpostRequest))
{
if(!ParseMultiReq(pReqList, (CCimHttpMultiMessage *)*ppReturnObject, strIDValue, bIsMpostRequest, bIsMicrosoftWMIClient, iHttpVersion, dwSimpleReqCount))
{
delete *ppReturnObject;
*ppReturnObject = NULL;
}
else
*pdwStatus = 200;
}
else
*pdwStatus = 500;
}
pReqList->Release ();
}
}
else
{
// Create a SIMPLEREQ object
//============================
*ppReturnObject = ParseSimpleReq(pRequestNode, strIDValue,
bIsMpostRequest, bIsMicrosoftWMIClient, iHttpVersion);
if(*ppReturnObject)
*pdwStatus = 200;
}
}
if (pRequestNode)
pRequestNode->Release ();
pNodeList->Release();
}
}
}
SysFreeString (bsProtocolVersion);
}
// If an object was not constructed, then strIDValue needs to be released
// Note that the strIDValue becomes a property of the request object since
// its constructor does not make a copy
if(!(*ppReturnObject))
{
SysFreeString (strIDValue);
if(*pdwStatus == 400)
*ppszCimError = CIM_REQUEST_NOT_VALID;
}
return TRUE;
}
//***************************************************************************
//
// IXMLDOMNode *GetMessageNode
//
// Description:
//
// Take the XML Document describing the request and extract the
// unique MESSAGE node.
//
// Parameters:
//
// pDocument Holds request in XML document form
// pdwStatus Holds HTTP response status on return
//
// Return Value:
//
// pointer to the node (or NULL if error)
//
//***************************************************************************
IXMLDOMNode *GetMessageNode(
IXMLDOMDocument *pDocument,
DWORD *pdwStatus,
LPSTR *ppszErrorHeaders
)
{
IXMLDOMNode *pMessage = NULL;
BOOLEAN bError = FALSE;
*ppszErrorHeaders = NULL;
*pdwStatus = 500;
// Get the XML Element at the top of the document
IXMLDOMElement *pDocumentElement = NULL;
if (SUCCEEDED(pDocument->get_documentElement(&pDocumentElement)) && pDocumentElement)
{
BSTR bsNodeName = NULL;
// This root element should be the "CIM" Element
if (SUCCEEDED(pDocumentElement->get_nodeName(&bsNodeName)) &&
(0 == _wcsicmp (CIM_TAG, bsNodeName)))
{
// We found the root element - check the attributes
// CIM Version
BSTR bsCIMVersion = NULL;
GetBstrAttribute (pDocumentElement, CIMVERSION_ATTRIBUTE, &bsCIMVersion);
if(bsCIMVersion && _wcsicmp(bsCIMVersion, L"2.0") == 0)
{
// DTD Version
BSTR bsDTDVersion = NULL;
GetBstrAttribute (pDocumentElement, DTDVERSION_ATTRIBUTE, &bsDTDVersion);
if(bsDTDVersion && _wcsicmp(bsDTDVersion, L"2.0") == 0)
{
// Now look for the MESSAGE tag
IXMLDOMNodeList *pNodeList2 = NULL;
if (SUCCEEDED(pDocumentElement->get_childNodes(&pNodeList2)) && pNodeList2)
{
IXMLDOMNode *pMessageNode = NULL;
bool bFoundMessage = false;
while (!bFoundMessage && SUCCEEDED(pNodeList2->nextNode (&pMessageNode))
&& pMessageNode)
{
BSTR bsNodeName2 = NULL;
// Next node should be the <MESSAGE> tag
if (SUCCEEDED(pMessageNode->get_nodeName(&bsNodeName2)) &&
(0 == _wcsicmp (MESSAGE_TAG, bsNodeName2)))
{
pMessage = pMessageNode;
pMessage->AddRef ();
bFoundMessage = true;
}
SysFreeString(bsNodeName2);
pMessageNode->Release();
pMessageNode = NULL;
}
pNodeList2->Release ();
}
}
else
{
bError = TRUE;
*pdwStatus = 501;
*ppszErrorHeaders = CIM_UNSUPPORTED_DTD_VERSION;
}
SysFreeString(bsDTDVersion);
}
else
{
bError = TRUE;
*pdwStatus = 501;
*ppszErrorHeaders = CIM_UNSUPPORTED_CIM_VERSION;
}
SysFreeString(bsCIMVersion);
}
else
{
bError = TRUE;
*pdwStatus = 400;
*ppszErrorHeaders = CIM_REQUEST_NOT_VALID;
}
SysFreeString(bsNodeName);
pDocumentElement->Release();
}
else
{
bError = TRUE;
*pdwStatus = 400;
*ppszErrorHeaders = CIM_REQUEST_NOT_VALID;
}
// If we had some error and still have a message node, then release it
if (bError && pMessage)
{
pMessage->Release ();
pMessage = NULL;
}
// If we found no error, but also no message node, then create an error
else if(!bError && !pMessage)
{
*pdwStatus = 400;
*ppszErrorHeaders = CIM_REQUEST_NOT_VALID;
}
return pMessage;
}
Reference in New Issue View Git Blame Copy Permalink