IUnknown* create_pi( xmlNodePtr pi )
{
dom_pi *This;
HRESULT hr;
This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
if ( !This )
return NULL;
This->lpVtbl = &dom_pi_vtbl;
This->ref = 1;
This->node_unk = create_basic_node( pi, (IUnknown*)&This->lpVtbl );
if(!This->node_unk)
{
HeapFree(GetProcessHeap(), 0, This);
return NULL;
}
hr = IUnknown_QueryInterface(This->node_unk, &IID_IXMLDOMNode, (LPVOID*)&This->node);
if(FAILED(hr))
{
IUnknown_Release(This->node_unk);
HeapFree( GetProcessHeap(), 0, This );
return NULL;
}
/* The ref on This->node is actually looped back into this object, so release it */
IXMLDOMNode_Release(This->node);
return (IUnknown*) &This->lpVtbl;
}
static HRESULT WINAPI domtext_put_dataType(
IXMLDOMText *iface,
BSTR dtName)
{
domtext *This = impl_from_IXMLDOMText( iface );
IXMLDOMNode* parent = NULL;
HRESULT hr;
TRACE("(%p)->(%p)\n", This, dtName);
if (!dtName)
return E_INVALIDARG;
hr = IXMLDOMText_get_parentNode(iface, &parent);
if (hr == S_OK)
{
hr = IXMLDOMNode_put_dataType(parent, dtName);
IXMLDOMNode_Release(parent);
}
else
{
hr = S_FALSE;
}
return hr;
}
static HRESULT selection_next(IUnknown *iface)
{
IXMLDOMNode *node;
HRESULT hr = IXMLDOMSelection_nextNode((IXMLDOMSelection*)iface, &node);
if (hr == S_OK) IXMLDOMNode_Release(node);
return hr;
}
static HRESULT WINAPI domtext_get_nodeTypedValue(
IXMLDOMText *iface,
VARIANT* var1)
{
domtext *This = impl_from_IXMLDOMText( iface );
IXMLDOMNode* parent = NULL;
HRESULT hr;
TRACE("(%p)->(%p)\n", This, var1);
if (!var1)
return E_INVALIDARG;
hr = IXMLDOMText_get_parentNode(iface, &parent);
if (hr == S_OK)
{
hr = IXMLDOMNode_get_nodeTypedValue(parent, var1);
IXMLDOMNode_Release(parent);
}
else
{
V_VT(var1) = VT_NULL;
V_BSTR(var1) = NULL;
hr = S_FALSE;
}
return hr;
}
static ULONG WINAPI xsltemplate_Release( IXSLTemplate *iface )
{
xsltemplate *This = impl_from_IXSLTemplate( iface );
ULONG ref = InterlockedDecrement( &This->ref );
TRACE("(%p)->(%d)\n", This, ref);
if ( ref == 0 )
{
if (This->node) IXMLDOMNode_Release( This->node );
heap_free( This );
}
return ref;
}
static ULONG WINAPI xslprocessor_Release( IXSLProcessor *iface )
{
xslprocessor *This = impl_from_IXSLProcessor( iface );
ULONG ref = InterlockedDecrement( &This->ref );
TRACE("(%p)->(%d)\n", This, ref);
if ( ref == 0 )
{
if (This->input) IXMLDOMNode_Release(This->input);
if (This->output) IStream_Release(This->output);
SysFreeString(This->outstr);
IXSLTemplate_Release(&This->stylesheet->IXSLTemplate_iface);
release_dispex(&This->dispex);
heap_free( This );
}
return ref;
}
static HRESULT WINAPI enumvariant_Next(
IEnumVARIANT *iface,
ULONG celt,
VARIANT *var,
ULONG *fetched)
{
enumvariant *This = impl_from_IEnumVARIANT( iface );
IXMLDOMNode *node;
ULONG ret_count = 0;
TRACE("(%p)->(%u %p %p)\n", This, celt, var, fetched);
if (fetched) *fetched = 0;
if (celt && !var) return E_INVALIDARG;
for (; celt > 0; celt--, var++, This->pos++)
{
IDispatch *disp = NULL;
HRESULT hr;
node = NULL;
hr = IXMLDOMSelection_get_item(This->selection, This->pos, &node);
if (hr != S_OK) break;
IXMLDOMNode_QueryInterface(node, &IID_IDispatch, (void**)&disp);
IXMLDOMNode_Release(node);
V_VT(var) = VT_DISPATCH;
V_DISPATCH(var) = disp;
ret_count++;
}
if (fetched) (*fetched)++;
/* we need to advance one step more for some reason */
if (ret_count)
IXMLDOMSelection_nextNode(This->selection, &node);
return celt == 0 ? S_OK : S_FALSE;
}
wchar_t * kull_m_xml_getAttribute(IXMLDOMNode *pNode, PCWSTR name)
{
wchar_t *result = NULL;
IXMLDOMNamedNodeMap *map;
IXMLDOMNode *nAttr;
BSTR bstrGeneric;
long length, i;
BOOL isMatch = FALSE;
if(IXMLDOMNode_get_attributes(pNode, &map) == S_OK)
{
if(IXMLDOMNamedNodeMap_get_length(map, &length) == S_OK)
{
for(i = 0; (i < length) && !isMatch; i++)
{
if(IXMLDOMNamedNodeMap_get_item(map, i, &nAttr) == S_OK)
{
if(IXMLDOMNode_get_nodeName(nAttr, &bstrGeneric) == S_OK)
{
isMatch = (_wcsicmp(name, bstrGeneric) == 0);
SysFreeString(bstrGeneric);
if(isMatch)
{
if(IXMLDOMNode_get_text(nAttr, &bstrGeneric) == S_OK)
{
kull_m_string_copy(&result, bstrGeneric);
SysFreeString(bstrGeneric);
}
}
}
IXMLDOMNode_Release(nAttr);
}
}
}
IXMLDOMNamedNodeMap_Release(map);
}
return result;
}
static ULONG WINAPI xslprocessor_Release( IXSLProcessor *iface )
{
xslprocessor *This = impl_from_IXSLProcessor( iface );
ULONG ref = InterlockedDecrement( &This->ref );
TRACE("(%p)->(%d)\n", This, ref);
if ( ref == 0 )
{
struct xslprocessor_par *par, *par2;
if (This->input) IXMLDOMNode_Release(This->input);
if (This->output) IStream_Release(This->output);
SysFreeString(This->outstr);
LIST_FOR_EACH_ENTRY_SAFE(par, par2, &This->params.list, struct xslprocessor_par, entry)
xslprocessor_par_free(&This->params, par);
IXSLTemplate_Release(&This->stylesheet->IXSLTemplate_iface);
heap_free( This );
}
return ref;
}
static HRESULT WINAPI xslprocessor_put_input( IXSLProcessor *iface, VARIANT input )
{
xslprocessor *This = impl_from_IXSLProcessor( iface );
IXMLDOMNode *input_node;
HRESULT hr;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&input));
/* try IXMLDOMNode directly first */
if (V_VT(&input) == VT_UNKNOWN)
hr = IUnknown_QueryInterface(V_UNKNOWN(&input), &IID_IXMLDOMNode, (void**)&input_node);
else if (V_VT(&input) == VT_DISPATCH)
hr = IDispatch_QueryInterface(V_DISPATCH(&input), &IID_IXMLDOMNode, (void**)&input_node);
else
{
IXMLDOMDocument *doc;
hr = DOMDocument_create(MSXML_DEFAULT, (void**)&doc);
if (hr == S_OK)
{
VARIANT_BOOL b;
hr = IXMLDOMDocument_load(doc, input, &b);
if (hr == S_OK)
hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&input_node);
IXMLDOMDocument_Release(doc);
}
}
if (hr == S_OK)
{
if (This->input) IXMLDOMNode_Release(This->input);
This->input = input_node;
}
return hr;
}
void kuhl_m_iis_apphost_genericEnumNodes(int argc, wchar_t * argv[], IXMLDOMDocument *pXMLDom, PCWSTR path, IISXMLType xmltype, LPCWSTR provider, LPCBYTE data, DWORD szData)
{
IXMLDOMNodeList *pNodes;
IXMLDOMNode *pNode;
DOMNodeType type;
BOOL mustBreak = FALSE;
long length, i;
if((IXMLDOMDocument_selectNodes(pXMLDom, (BSTR) path, &pNodes) == S_OK) && pNodes)
{
if(IXMLDOMNodeList_get_length(pNodes, &length) == S_OK)
{
for(i = 0; (i < length) && !mustBreak; i++)
{
if((IXMLDOMNodeList_get_item(pNodes, i, &pNode) == S_OK) && pNode)
{
if((IXMLDOMNode_get_nodeType(pNode, &type) == S_OK) && (type == NODE_ELEMENT))
{
switch(xmltype)
{
case IISXMLType_ApplicationPools:
kuhl_m_iis_apphost_apppool(argc, argv, pXMLDom, pNode);
break;
case IISXMLType_Sites:
kuhl_m_iis_apphost_site(argc, argv, pXMLDom, pNode);
break;
case IISXMLType_Providers:
mustBreak = kuhl_m_iis_apphost_provider(argc, argv, pXMLDom, pNode, provider, data, szData);
break;
}
}
IXMLDOMNode_Release(pNode);
}
}
}
}
}
static HRESULT WINAPI domtext_put_nodeTypedValue(
IXMLDOMText *iface,
VARIANT value)
{
domtext *This = impl_from_IXMLDOMText( iface );
IXMLDOMNode* parent = NULL;
HRESULT hr;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
hr = IXMLDOMText_get_parentNode(iface, &parent);
if (hr == S_OK)
{
hr = IXMLDOMNode_put_nodeTypedValue(parent, value);
IXMLDOMNode_Release(parent);
}
else
{
hr = S_FALSE;
}
return hr;
}
/*******************************************************************************
* GAMEUX_ParseGameDefinition
*
* Helper function, loads data from given XML element into fields of GAME_DATA
* structure
*
* Parameters:
* lpXMLGameDefinitionElement [I] Game Definition XML element
* GameData [O] structure where data loaded from
* XML element will be stored in
*/
static HRESULT GAMEUX_ParseGameDefinition(
IXMLDOMElement *gdElement,
struct GAMEUX_GAME_DATA *GameData)
{
static const WCHAR sGameId[] = {'g','a','m','e','I','D',0};
HRESULT hr = S_OK;
BSTR bstrAttribute;
VARIANT variant;
IXMLDOMNodeList *childrenList;
IXMLDOMNode *nextNode;
IXMLDOMElement *nextElement;
TRACE("(%p, %p)\n", gdElement, GameData);
bstrAttribute = SysAllocString(sGameId);
if(!bstrAttribute)
hr = E_OUTOFMEMORY;
hr = IXMLDOMElement_getAttribute(gdElement, bstrAttribute, &variant);
if(SUCCEEDED(hr))
{
hr = ( GUIDFromStringW(V_BSTR(&variant), &GameData->guidApplicationId)==TRUE ? S_OK : E_FAIL);
SysFreeString(V_BSTR(&variant));
}
SysFreeString(bstrAttribute);
/* browse subnodes */
if(SUCCEEDED(hr))
hr = IXMLDOMElement_get_childNodes(gdElement, &childrenList);
if(SUCCEEDED(hr))
{
do
{
hr = IXMLDOMNodeList_nextNode(childrenList, &nextNode);
if(hr == S_OK)
{
hr = IXMLDOMNode_QueryInterface(nextNode, &IID_IXMLDOMElement,
(LPVOID*)&nextElement);
if(SUCCEEDED(hr))
{
hr = GAMEUX_ProcessGameDefinitionElement(nextElement, GameData);
IXMLDOMElement_Release(nextElement);
}
IXMLDOMNode_Release(nextNode);
}
}
while(hr == S_OK);
hr = S_OK;
IXMLDOMNodeList_Release(childrenList);
}
return hr;
}
static HRESULT WINAPI schema_cache_add(IXMLDOMSchemaCollection2* iface, BSTR uri, VARIANT var)
{
schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
xmlChar* name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
TRACE("(%p)->(%s %s)\n", This, debugstr_w(uri), debugstr_variant(&var));
if (This->read_only) return E_FAIL;
switch (V_VT(&var))
{
case VT_NULL:
{
cache_remove_entry(This, name);
}
break;
case VT_BSTR:
{
cache_entry* entry = cache_entry_from_url(var, name, This->version);
if (entry)
{
cache_entry_add_ref(entry);
}
else
{
heap_free(name);
return E_FAIL;
}
cache_add_entry(This, name, entry);
}
break;
case VT_DISPATCH:
{
xmlDocPtr doc = NULL;
cache_entry* entry;
CacheEntryType type;
IXMLDOMNode* domnode = NULL;
IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IXMLDOMNode, (void**)&domnode);
if (domnode)
doc = xmlNodePtr_from_domnode(domnode, XML_DOCUMENT_NODE)->doc;
if (!doc)
{
IXMLDOMNode_Release(domnode);
heap_free(name);
return E_INVALIDARG;
}
type = cache_type_from_xmlDocPtr(doc);
if (type == CacheEntryType_XSD)
{
entry = cache_entry_from_xsd_doc(doc, name, This->version);
}
else if (type == CacheEntryType_XDR)
{
entry = cache_entry_from_xdr_doc(doc, name, This->version);
}
else
{
WARN("invalid schema!\n");
entry = NULL;
}
IXMLDOMNode_Release(domnode);
if (entry)
{
cache_entry_add_ref(entry);
}
else
{
heap_free(name);
return E_FAIL;
}
cache_add_entry(This, name, entry);
}
break;
default:
{
heap_free(name);
return E_INVALIDARG;
}
}
heap_free(name);
return S_OK;
}
static inline HRESULT handle_xml_load(BindStatusCallback *This)
{
static const WCHAR selectW[] = {'p','r','o','c','e','s','s','i','n','g','-',
'i','n','s','t','r','u','c','t','i','o','n','(','\'','x','m','l',
'-','s','t','y','l','e','s','h','e','e','t','\'',')',0};
static const WCHAR hrefW[] = {'h','r','e','f','=',0};
IXMLDOMDocument3 *xml = NULL, *xsl = NULL;
IXMLDOMNode *stylesheet;
IBindCtx *pbc;
IMoniker *mon;
LPOLESTR xsl_url;
LARGE_INTEGER off;
VARIANT_BOOL succ;
VARIANT var;
WCHAR *href = NULL, *p;
BSTR bstr;
HRESULT hres;
off.QuadPart = 0;
hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
if(FAILED(hres))
return display_error_page(This);
hres = DOMDocument_create(MSXML_DEFAULT, NULL, (void**)&xml);
if(FAILED(hres))
return display_error_page(This);
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)This->stream;
hres = IXMLDOMDocument3_load(xml, var, &succ);
if(FAILED(hres) || !succ) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
V_VT(&var) = VT_EMPTY;
bstr = SysAllocString(selectW);
hres = IXMLDOMDocument3_selectSingleNode(xml, bstr, &stylesheet);
SysFreeString(bstr);
if(hres != S_OK) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = IXMLDOMNode_get_nodeValue(stylesheet, &var);
IXMLDOMNode_Release(stylesheet);
if(SUCCEEDED(hres) && V_VT(&var)!=VT_BSTR) {
FIXME("Variant type %d not supported\n", V_VT(&var));
VariantClear(&var);
hres = E_FAIL;
}
if(FAILED(hres)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
/* TODO: fix parsing processing instruction value */
if((p = strstrW(V_BSTR(&var), hrefW))) {
p += sizeof(hrefW)/sizeof(WCHAR)-1;
if(*p!='\'' && *p!='\"') p = NULL;
else {
href = p+1;
p = strchrW(href, *p);
}
}
if(p) {
*p = 0;
} else {
VariantClear(&var);
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = CreateURLMonikerEx(This->mon, href, &mon, 0);
VariantClear(&var);
if(FAILED(hres)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = CreateBindCtx(0, &pbc);
if(SUCCEEDED(hres)) {
hres = IMoniker_GetDisplayName(mon, pbc, NULL, &xsl_url);
IMoniker_Release(mon);
IBindCtx_Release(pbc);
}
if(FAILED(hres)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(xsl_url);
CoTaskMemFree(xsl_url);
if(!V_BSTR(&var)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = DOMDocument_create(MSXML_DEFAULT, NULL, (void**)&xsl);
if(FAILED(hres)) {
VariantClear(&var);
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
/* TODO: do the binding asynchronously */
hres = IXMLDOMDocument3_load(xsl, var, &succ);
VariantClear(&var);
if(FAILED(hres) || !succ) {
IXMLDOMDocument3_Release(xsl);
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = IXMLDOMDocument3_transformNode(xml, (IXMLDOMNode*)xsl, &bstr);
IXMLDOMDocument3_Release(xsl);
IXMLDOMDocument3_Release(xml);
if(FAILED(hres))
return display_error_page(This);
hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
if(FAILED(hres)) {
SysFreeString(bstr);
return display_error_page(This);
}
hres = IStream_Write(This->stream, (BYTE*)bstr,
SysStringLen(bstr)*sizeof(WCHAR), NULL);
SysFreeString(bstr);
if(FAILED(hres))
return display_error_page(This);
return report_data(This);
}
static void xsltemplate_set_node( xsltemplate *This, IXMLDOMNode *node )
{
if (This->node) IXMLDOMNode_Release(This->node);
This->node = node;
if (node) IXMLDOMNode_AddRef(node);
}
/*******************************************************************
* GAMEUX_updateStatisticsFile
*
* Helper function updating data stored in statistics file
*
* Parameters:
* data [I] pointer to struct containing
* statistics data
*/
static HRESULT GAMEUX_updateStatisticsFile(struct GAMEUX_STATS *stats)
{
static const WCHAR sStatistics[] = {'S','t','a','t','i','s','t','i','c','s',0};
static const WCHAR sCategory[] = {'C','a','t','e','g','o','r','y',0};
static const WCHAR sIndex[] = {'I','n','d','e','x',0};
static const WCHAR sStatistic[] = {'S','t','a','t','i','s','t','i','c',0};
static const WCHAR sName[] = {'N','a','m','e',0};
static const WCHAR sValue[] = {'V','a','l','u','e',0};
HRESULT hr = S_OK;
IXMLDOMDocument *document;
IXMLDOMElement *root, *categoryElement, *statisticsElement;
IXMLDOMNode *categoryNode, *statisticsNode;
VARIANT vStatsFilePath, vValue;
BSTR bstrStatistics = NULL, bstrCategory = NULL, bstrIndex = NULL,
bstrStatistic = NULL, bstrName = NULL, bstrValue = NULL;
int i, j;
TRACE("(%p)\n", stats);
V_VT(&vStatsFilePath) = VT_BSTR;
V_BSTR(&vStatsFilePath) = SysAllocString(stats->sStatsFile);
if(!V_BSTR(&vStatsFilePath))
hr = E_OUTOFMEMORY;
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDOMDocument, (void**)&document);
if(SUCCEEDED(hr))
{
bstrStatistics = SysAllocString(sStatistics);
if(!bstrStatistics)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
hr = IXMLDOMDocument_createElement(document, bstrStatistics, &root);
if(SUCCEEDED(hr))
{
bstrCategory = SysAllocString(sCategory);
if(!bstrCategory)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrIndex = SysAllocString(sIndex);
if(!bstrIndex)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrStatistic = SysAllocString(sStatistic);
if(!bstrStatistic)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrName = SysAllocString(sName);
if(!bstrName)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrValue = SysAllocString(sValue);
if(!bstrValue)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
for(i=0; i<MAX_CATEGORIES; ++i)
{
if(lstrlenW(stats->categories[i].sName)==0)
continue;
V_VT(&vValue) = VT_INT;
V_INT(&vValue) = NODE_ELEMENT;
hr = IXMLDOMDocument_createNode(document, vValue, bstrCategory, NULL, &categoryNode);
if(SUCCEEDED(hr))
hr = IXMLDOMNode_QueryInterface(categoryNode, &IID_IXMLDOMElement, (LPVOID*)&categoryElement);
V_INT(&vValue) = i;
if(SUCCEEDED(hr))
hr = IXMLDOMElement_setAttribute(categoryElement, bstrIndex, vValue);
if(SUCCEEDED(hr))
{
V_VT(&vValue) = VT_BSTR;
V_BSTR(&vValue) = SysAllocString(stats->categories[i].sName);
if(!V_BSTR(&vValue))
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
TRACE("storing category %d: %s\n", i, debugstr_w(V_BSTR(&vValue)));
hr = IXMLDOMElement_setAttribute(categoryElement, bstrName, vValue);
}
SysFreeString(V_BSTR(&vValue));
if(SUCCEEDED(hr))
{
for(j=0; j<MAX_STATS_PER_CATEGORY; ++j)
{
if(lstrlenW(stats->categories[i].stats[j].sName)==0)
continue;
V_VT(&vValue) = VT_INT;
V_INT(&vValue) = NODE_ELEMENT;
hr = IXMLDOMDocument_createNode(document, vValue, bstrStatistic, NULL, &statisticsNode);
if(SUCCEEDED(hr))
hr = IXMLDOMNode_QueryInterface(statisticsNode, &IID_IXMLDOMElement, (LPVOID*)&statisticsElement);
V_INT(&vValue) = j;
if(SUCCEEDED(hr))
hr = IXMLDOMElement_setAttribute(statisticsElement, bstrIndex, vValue);
if(SUCCEEDED(hr))
{
V_VT(&vValue) = VT_BSTR;
V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sName);
if(!V_BSTR(&vValue))
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
TRACE(" storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue)));
hr = IXMLDOMElement_setAttribute(statisticsElement, bstrName, vValue);
}
SysFreeString(V_BSTR(&vValue));
if(SUCCEEDED(hr))
{
V_VT(&vValue) = VT_BSTR;
V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sValue);
if(!V_BSTR(&vValue))
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
TRACE(" storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue)));
hr = IXMLDOMElement_setAttribute(statisticsElement, bstrValue, vValue);
}
SysFreeString(V_BSTR(&vValue));
if(SUCCEEDED(hr))
hr = IXMLDOMNode_appendChild(categoryNode, statisticsNode, &statisticsNode);
IXMLDOMElement_Release(statisticsElement);
IXMLDOMNode_Release(statisticsNode);
}
}
if(SUCCEEDED(hr))
hr = IXMLDOMElement_appendChild(root, categoryNode, &categoryNode);
IXMLDOMElement_Release(categoryElement);
IXMLDOMNode_Release(categoryNode);
if(FAILED(hr))
break;
}
if(SUCCEEDED(hr))
hr = IXMLDOMDocument_putref_documentElement(document, root);
IXMLDOMElement_Release(root);
TRACE("saving game statistics in %s file\n", debugstr_w(stats->sStatsFile));
if(SUCCEEDED(hr))
hr = GAMEUX_createStatsDirectory(stats->sStatsFile);
if(SUCCEEDED(hr))
hr = IXMLDOMDocument_save(document, vStatsFilePath);
IXMLDOMDocument_Release(document);
SysFreeString(bstrValue);
SysFreeString(bstrName);
SysFreeString(bstrStatistic);
SysFreeString(bstrIndex);
SysFreeString(bstrCategory);
SysFreeString(bstrStatistics);
SysFreeString(V_BSTR(&vStatsFilePath));
TRACE("ret=0x%x\n", hr);
return hr;
}
/*******************************************************************
* GAMEUX_loadGameStatisticsFromFile
* Helper function, loads game statistics from file and stores them
* in the structure.
*
* Parameters:
* data [I/O] structure containing file name to
* load and data fields to store data in
*/
static HRESULT GAMEUX_loadStatisticsFromFile(struct GAMEUX_STATS *data)
{
static const WCHAR sStatistics[] = {'S','t','a','t','i','s','t','i','c','s',0};
static const WCHAR sCategory[] = {'C','a','t','e','g','o','r','y',0};
static const WCHAR sIndex[] = {'I','n','d','e','x',0};
static const WCHAR sStatistic[] = {'S','t','a','t','i','s','t','i','c',0};
static const WCHAR sName[] = {'N','a','m','e',0};
static const WCHAR sValue[] = {'V','a','l','u','e',0};
HRESULT hr = S_OK;
IXMLDOMDocument *document = NULL;
IXMLDOMElement *root = NULL, *categoryElement, *statisticElement;
IXMLDOMNode *categoryNode, *statisticNode;
IXMLDOMNodeList *rootChildren = NULL, *categoryChildren;
VARIANT vStatsFilePath, vValue;
BSTR bstrStatistics = NULL, bstrCategory = NULL, bstrIndex = NULL,
bstrStatistic = NULL, bstrName = NULL, bstrValue = NULL;
VARIANT_BOOL isSuccessful = VARIANT_FALSE;
int i, j;
TRACE("(%p)\n", data);
V_VT(&vStatsFilePath) = VT_BSTR;
V_BSTR(&vStatsFilePath) = SysAllocString(data->sStatsFile);
if(!V_BSTR(&vStatsFilePath))
hr = E_OUTOFMEMORY;
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&document);
if(SUCCEEDED(hr))
{
bstrStatistics = SysAllocString(sStatistics);
if(!bstrStatistics)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrCategory = SysAllocString(sCategory);
if(!bstrCategory)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrIndex = SysAllocString(sIndex);
if(!bstrIndex)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrStatistic = SysAllocString(sStatistic);
if(!bstrStatistic)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrName = SysAllocString(sName);
if(!bstrName)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
{
bstrValue = SysAllocString(sValue);
if(!bstrValue)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
hr = IXMLDOMDocument_load(document, vStatsFilePath, &isSuccessful);
if(hr == S_OK && isSuccessful != VARIANT_TRUE)
hr = S_FALSE;
if( hr == S_OK )
hr = IXMLDOMDocument_get_documentElement(document, &root);
if(hr == S_OK)
hr = IXMLDOMElement_get_childNodes(root, &rootChildren);
if(hr == S_OK)
{
hr = S_OK;
while(hr == S_OK)
{
hr = IXMLDOMNodeList_nextNode(rootChildren, &categoryNode);
if(hr == S_OK)
{
hr = IXMLDOMNode_QueryInterface(categoryNode, &IID_IXMLDOMElement, (LPVOID*)&categoryElement);
if(SUCCEEDED(hr))
{
hr = IXMLDOMElement_getAttribute(categoryElement, bstrIndex, &vValue);
if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
hr = E_FAIL;
if(SUCCEEDED(hr))
{
i = StrToIntW(V_BSTR(&vValue));
hr = IXMLDOMElement_getAttribute(categoryElement, bstrName, &vValue);
if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
hr = E_FAIL;
}
if(SUCCEEDED(hr))
{
lstrcpynW(data->categories[i].sName, V_BSTR(&vValue), MAX_CATEGORY_LENGTH);
TRACE("category %d name %s\n", i, debugstr_w(data->categories[i].sName));
hr = IXMLDOMElement_get_childNodes(categoryElement, &categoryChildren);
}
if(SUCCEEDED(hr))
{
hr = S_OK;
while(hr == S_OK)
{
hr = IXMLDOMNodeList_nextNode(categoryChildren, &statisticNode);
if(hr == S_OK)
{
hr = IXMLDOMNode_QueryInterface(statisticNode, &IID_IXMLDOMElement, (LPVOID*)&statisticElement);
if(SUCCEEDED(hr))
{
hr = IXMLDOMElement_getAttribute(statisticElement, bstrIndex, &vValue);
if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
hr = E_FAIL;
if(SUCCEEDED(hr))
{
j = StrToIntW(V_BSTR(&vValue));
hr = IXMLDOMElement_getAttribute(statisticElement, bstrName, &vValue);
if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
hr = E_FAIL;
}
if(SUCCEEDED(hr))
{
lstrcpynW(data->categories[i].stats[j].sName, V_BSTR(&vValue), MAX_NAME_LENGTH);
hr = IXMLDOMElement_getAttribute(statisticElement, bstrValue, &vValue);
if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
hr = E_FAIL;
}
if(SUCCEEDED(hr))
{
lstrcpynW(data->categories[i].stats[j].sValue, V_BSTR(&vValue), MAX_VALUE_LENGTH);
TRACE("statistic %d name %s value %s\n", j,
debugstr_w(data->categories[i].stats[j].sName),
debugstr_w(data->categories[i].stats[j].sValue));
}
IXMLDOMElement_Release(statisticElement);
}
IXMLDOMNode_Release(statisticNode);
}
}
if(SUCCEEDED(hr))
hr = S_OK;
}
IXMLDOMElement_Release(categoryElement);
}
IXMLDOMNode_Release(categoryNode);
}
}
if(SUCCEEDED(hr))
hr = S_OK;
}
if(rootChildren) IXMLDOMNodeList_Release(rootChildren);
if(root) IXMLDOMElement_Release(root);
if(document) IXMLDOMDocument_Release(document);
SysFreeString(bstrValue);
SysFreeString(bstrName);
SysFreeString(bstrStatistic);
SysFreeString(bstrIndex);
SysFreeString(bstrCategory);
SysFreeString(bstrStatistics);
SysFreeString(V_BSTR(&vStatsFilePath));
return hr;
}
HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
IXMLDOMNode **ret)
{
IXMLDOMNode *before = NULL;
xmlnode *node_obj;
int refcount = 0;
xmlDocPtr doc;
HRESULT hr;
if(!new_child)
return E_INVALIDARG;
node_obj = get_node_obj(new_child);
if(!node_obj) return E_FAIL;
switch(V_VT(ref_child))
{
case VT_EMPTY:
case VT_NULL:
break;
case VT_UNKNOWN:
case VT_DISPATCH:
if (V_UNKNOWN(ref_child))
{
hr = IUnknown_QueryInterface(V_UNKNOWN(ref_child), &IID_IXMLDOMNode, (void**)&before);
if(FAILED(hr)) return hr;
}
break;
default:
FIXME("refChild var type %x\n", V_VT(ref_child));
return E_FAIL;
}
TRACE("new child %p, This->node %p\n", node_obj->node, This->node);
if(!node_obj->node->parent)
if(xmldoc_remove_orphan(node_obj->node->doc, node_obj->node) != S_OK)
WARN("%p is not an orphan of %p\n", node_obj->node, node_obj->node->doc);
refcount = xmlnode_get_inst_cnt(node_obj);
if(before)
{
xmlnode *before_node_obj = get_node_obj(before);
IXMLDOMNode_Release(before);
if(!before_node_obj) return E_FAIL;
/* unlink from current parent first */
if(node_obj->parent)
{
hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
}
doc = node_obj->node->doc;
/* refs count including subtree */
if (doc != before_node_obj->node->doc)
refcount = xmlnode_get_inst_cnt(node_obj);
if (refcount) xmldoc_add_refs(before_node_obj->node->doc, refcount);
xmlAddPrevSibling(before_node_obj->node, node_obj->node);
if (refcount) xmldoc_release_refs(doc, refcount);
node_obj->parent = This->parent;
}
else
{
/* unlink from current parent first */
if(node_obj->parent)
{
hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
}
doc = node_obj->node->doc;
if (doc != This->node->doc)
refcount = xmlnode_get_inst_cnt(node_obj);
if (refcount) xmldoc_add_refs(This->node->doc, refcount);
/* xmlAddChild doesn't unlink node from previous parent */
xmlUnlinkNode(node_obj->node);
xmlAddChild(This->node, node_obj->node);
if (refcount) xmldoc_release_refs(doc, refcount);
node_obj->parent = This->iface;
}
if(ret)
{
IXMLDOMNode_AddRef(new_child);
*ret = new_child;
}
TRACE("ret S_OK\n");
return S_OK;
}
void kuhl_m_iis_apphost_site(int argc, wchar_t * argv[], IXMLDOMDocument *pXMLDom, IXMLDOMNode *pNode)
{
PWSTR gen;
IXMLDOMNodeList *pAppNodes, *pVdirNodes;
IXMLDOMNode *pAppNode, *pVdirNode;
DOMNodeType type;
long lengthApp, lengthVdir, i, j;
if(gen = kull_m_xml_getAttribute(pNode, L"name"))
{
kprintf(L"\n* Site: \'%s\'\n", gen);
LocalFree(gen);
if((IXMLDOMNode_selectNodes(pNode, L"application", &pAppNodes) == S_OK) && pAppNodes)
{
if(IXMLDOMNodeList_get_length(pAppNodes, &lengthApp) == S_OK)
{
for(i = 0; i < lengthApp; i++)
{
if((IXMLDOMNodeList_get_item(pAppNodes, i, &pAppNode) == S_OK) && pAppNode)
{
if((IXMLDOMNode_get_nodeType(pAppNode, &type) == S_OK) && (type == NODE_ELEMENT))
{
if(gen = kull_m_xml_getAttribute(pAppNode, L"path"))
{
kprintf(L" > Application Path: %s\n", gen);
LocalFree(gen);
if((IXMLDOMNode_selectNodes(pAppNode, L"virtualDirectory", &pVdirNodes) == S_OK) && pVdirNodes)
{
if(IXMLDOMNodeList_get_length(pVdirNodes, &lengthVdir) == S_OK)
{
for(j = 0; j < lengthVdir; j++)
{
if((IXMLDOMNodeList_get_item(pVdirNodes, j, &pVdirNode) == S_OK) && pVdirNode)
{
if((IXMLDOMNode_get_nodeType(pVdirNode, &type) == S_OK) && (type == NODE_ELEMENT))
{
if(gen = kull_m_xml_getAttribute(pVdirNode, L"path"))
{
kprintf(L" - VirtualDirectory Path: %s ( ", gen);
LocalFree(gen);
if(gen = kull_m_xml_getAttribute(pVdirNode, L"physicalPath"))
{
kprintf(L"%s", gen);
LocalFree(gen);
}
kprintf(L" )\n");
if(gen = kull_m_xml_getAttribute(pVdirNode, L"userName"))
{
kprintf(L" Username: %s\n", gen);
LocalFree(gen);
if(gen = kull_m_xml_getAttribute(pVdirNode, L"password"))
{
kprintf(L" Password: %s\n", gen);
kuhl_m_iis_maybeEncrypted(argc, argv, pXMLDom, gen);
LocalFree(gen);
}
}
}
}
IXMLDOMNode_Release(pVdirNode);
}
}
}
}
}
}
IXMLDOMNode_Release(pAppNode);
}
}
}
}
}
}
/*******************************************************************************
* GAMEUX_ParseGDFBinary
*
* Helper function, loads given binary and parses embed GDF if there's any.
*
* Parameters:
* GameData [I/O] Structure with game's data. Content of field
* sGDFBinaryPath defines path to binary, from
* which embed GDF will be loaded. Data from
* GDF will be stored in other fields of this
* structure.
*/
static HRESULT GAMEUX_ParseGDFBinary(struct GAMEUX_GAME_DATA *GameData)
{
static const WCHAR sRes[] = {'r','e','s',':','/','/',0};
static const WCHAR sDATA[] = {'D','A','T','A',0};
static const WCHAR sSlash[] = {'/',0};
HRESULT hr = S_OK;
WCHAR sResourcePath[MAX_PATH];
VARIANT variant;
VARIANT_BOOL isSuccessful;
IXMLDOMDocument *document;
IXMLDOMNode *gdNode;
IXMLDOMElement *root, *gdElement;
TRACE("(%p)->sGDFBinaryPath = %s\n", GameData, debugstr_w(GameData->sGDFBinaryPath));
/* prepare path to GDF, using res:// prefix */
lstrcpyW(sResourcePath, sRes);
lstrcatW(sResourcePath, GameData->sGDFBinaryPath);
lstrcatW(sResourcePath, sSlash);
lstrcatW(sResourcePath, sDATA);
lstrcatW(sResourcePath, sSlash);
lstrcatW(sResourcePath, ID_GDF_XML_STR);
hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDOMDocument, (void**)&document);
if(SUCCEEDED(hr))
{
/* load GDF into MSXML */
V_VT(&variant) = VT_BSTR;
V_BSTR(&variant) = SysAllocString(sResourcePath);
if(!V_BSTR(&variant))
hr = E_OUTOFMEMORY;
if(SUCCEEDED(hr))
{
hr = IXMLDOMDocument_load(document, variant, &isSuccessful);
if(hr == S_FALSE || isSuccessful == VARIANT_FALSE)
hr = E_FAIL;
}
SysFreeString(V_BSTR(&variant));
if(SUCCEEDED(hr))
{
hr = IXMLDOMDocument_get_documentElement(document, &root);
if(hr == S_FALSE)
hr = E_FAIL;
}
if(SUCCEEDED(hr))
{
hr = IXMLDOMElement_get_firstChild(root, &gdNode);
if(hr == S_FALSE)
hr = E_FAIL;
if(SUCCEEDED(hr))
{
hr = IXMLDOMNode_QueryInterface(gdNode, &IID_IXMLDOMElement, (LPVOID*)&gdElement);
if(SUCCEEDED(hr))
{
hr = GAMEUX_ParseGameDefinition(gdElement, GameData);
IXMLDOMElement_Release(gdElement);
}
IXMLDOMNode_Release(gdNode);
}
IXMLDOMElement_Release(root);
}
IXMLDOMDocument_Release(document);
}
return hr;
}
static HRESULT WINAPI schema_cache_add(IXMLDOMSchemaCollection2* iface, BSTR uri, VARIANT var)
{
schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
xmlChar* name = xmlChar_from_wchar(uri);
TRACE("(%p)->(%s, var(vt %x))\n", This, debugstr_w(uri), V_VT(&var));
switch (V_VT(&var))
{
case VT_NULL:
{
xmlHashRemoveEntry(This->cache, name, cache_free);
}
break;
case VT_BSTR:
{
xmlChar* url = xmlChar_from_wchar(V_BSTR(&var));
cache_entry* entry = cache_entry_from_url((char const*)url);
heap_free(url);
if (entry)
{
cache_entry_add_ref(entry);
}
else
{
heap_free(name);
return E_FAIL;
}
xmlHashRemoveEntry(This->cache, name, cache_free);
xmlHashAddEntry(This->cache, name, entry);
}
break;
case VT_DISPATCH:
{
xmlDocPtr doc = NULL;
cache_entry* entry;
SCHEMA_TYPE type;
IXMLDOMNode* domnode = NULL;
IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IXMLDOMNode, (void**)&domnode);
if (domnode)
doc = xmlNodePtr_from_domnode(domnode, XML_DOCUMENT_NODE)->doc;
if (!doc)
{
IXMLDOMNode_Release(domnode);
heap_free(name);
return E_INVALIDARG;
}
type = schema_type_from_xmlDocPtr(doc);
if (type == SCHEMA_TYPE_XSD)
{
entry = cache_entry_from_xsd_doc(doc);
}
else if (type == SCHEMA_TYPE_XDR)
{
entry = cache_entry_from_xdr_doc(doc);
}
else
{
WARN("invalid schema!\n");
entry = NULL;
}
IXMLDOMNode_Release(domnode);
if (entry)
{
cache_entry_add_ref(entry);
}
else
{
heap_free(name);
return E_FAIL;
}
xmlHashRemoveEntry(This->cache, name, cache_free);
xmlHashAddEntry(This->cache, name, entry);
}
break;
default:
{
heap_free(name);
return E_INVALIDARG;
}
}
heap_free(name);
return S_OK;
}
