dlls/mscoree/config.c

   1 /*
   2  * Configuration file parsing
   3  *
   4  * Copyright 2010 Vincent Povirk
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winreg.h"
  28 #include "ole2.h"
  29 #include "msxml2.h"
  30 #include "mscoree.h"
  31 #include "corhdr.h"
  32 #include "corerror.h"
  33 #include "metahost.h"
  34 #include "cordebug.h"
  35 #include "wine/list.h"
  36 #include "mscoree_private.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL( mscoree );
  41
  42 enum parse_state
  43 {
  44     STATE_ASSEMBLY_BINDING,
  45     STATE_ROOT,
  46     STATE_CONFIGURATION,
  47     STATE_PROBING,
  48     STATE_RUNTIME,
  49     STATE_STARTUP,
  50     STATE_UNKNOWN
  51 };
  52
  53 typedef struct ConfigFileHandler
  54 {
  55     ISAXContentHandler ISAXContentHandler_iface;
  56     ISAXErrorHandler ISAXErrorHandler_iface;
  57     LONG ref;
  58     enum parse_state states[16];
  59     int statenum;
  60     parsed_config_file *result;
  61 } ConfigFileHandler;
  62
  63 typedef struct
  64 {
  65     IStream IStream_iface;
  66     LONG ref;
  67     HANDLE file;
  68 } ConfigStream;
  69
  70 static inline ConfigStream *impl_from_IStream(IStream *iface)
  71 {
  72     return CONTAINING_RECORD(iface, ConfigStream, IStream_iface);
  73 }
  74
  75 static HRESULT WINAPI ConfigStream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
  76 {
  77     ConfigStream *This = impl_from_IStream(iface);
  78
  79     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  80
  81     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IStream))
  82         *ppv = &This->IStream_iface;
  83     else
  84     {
  85         WARN("Not supported iface %s\n", debugstr_guid(riid));
  86         *ppv = NULL;
  87         return E_NOINTERFACE;
  88     }
  89
  90     IUnknown_AddRef((IUnknown*)*ppv);
  91     return S_OK;
  92 }
  93
  94 static ULONG WINAPI ConfigStream_AddRef(IStream *iface)
  95 {
  96     ConfigStream *This = impl_from_IStream(iface);
  97     ULONG ref = InterlockedIncrement(&This->ref);
  98
  99     TRACE("(%p) ref=%u\n", This, ref);
 100
 101     return ref;
 102 }
 103
 104 static ULONG WINAPI ConfigStream_Release(IStream *iface)
 105 {
 106     ConfigStream *This = impl_from_IStream(iface);
 107     ULONG ref = InterlockedDecrement(&This->ref);
 108
 109     TRACE("(%p) ref=%u\n",This, ref);
 110
 111     if (!ref)
 112     {
 113         CloseHandle(This->file);
 114         HeapFree(GetProcessHeap(), 0, This);
 115     }
 116
 117     return ref;
 118 }
 119
 120 static HRESULT WINAPI ConfigStream_Read(IStream *iface, void *buf, ULONG size, ULONG *ret_read)
 121 {
 122     ConfigStream *This = impl_from_IStream(iface);
 123     DWORD read = 0;
 124
 125     TRACE("(%p)->(%p %u %p)\n", This, buf, size, ret_read);
 126
 127     if (!ReadFile(This->file, buf, size, &read, NULL))
 128     {
 129         WARN("error %d reading file\n", GetLastError());
 130         return HRESULT_FROM_WIN32(GetLastError());
 131     }
 132
 133     if (ret_read) *ret_read = read;
 134     return S_OK;
 135 }
 136
 137 static HRESULT WINAPI ConfigStream_Write(IStream *iface, const void *buf, ULONG size, ULONG *written)
 138 {
 139     ConfigStream *This = impl_from_IStream(iface);
 140     TRACE("(%p)->(%p %u %p)\n", This, buf, size, written);
 141     return E_FAIL;
 142 }
 143
 144 static HRESULT WINAPI ConfigStream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
 145                                         DWORD dwOrigin, ULARGE_INTEGER *pNewPos)
 146 {
 147     ConfigStream *This = impl_from_IStream(iface);
 148     TRACE("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, pNewPos);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI ConfigStream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
 153 {
 154     ConfigStream *This = impl_from_IStream(iface);
 155     TRACE("(%p)->(%d)\n", This, libNewSize.u.LowPart);
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI ConfigStream_CopyTo(IStream *iface, IStream *stream, ULARGE_INTEGER size,
 160                                           ULARGE_INTEGER *read, ULARGE_INTEGER *written)
 161 {
 162     ConfigStream *This = impl_from_IStream(iface);
 163     FIXME("(%p)->(%p %d %p %p)\n", This, stream, size.u.LowPart, read, written);
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI ConfigStream_Commit(IStream *iface, DWORD flags)
 168 {
 169     ConfigStream *This = impl_from_IStream(iface);
 170     FIXME("(%p,%d)\n", This, flags);
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI ConfigStream_Revert(IStream *iface)
 175 {
 176     ConfigStream *This = impl_from_IStream(iface);
 177     TRACE("(%p)\n", This);
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI ConfigStream_LockUnlockRegion(IStream *iface, ULARGE_INTEGER libOffset,
 182                                                     ULARGE_INTEGER cb, DWORD dwLockType)
 183 {
 184     ConfigStream *This = impl_from_IStream(iface);
 185     TRACE("(%p,%d,%d,%d)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI ConfigStream_Stat(IStream *iface, STATSTG *lpStat, DWORD grfStatFlag)
 190 {
 191     ConfigStream *This = impl_from_IStream(iface);
 192     FIXME("(%p,%p,%d)\n", This, lpStat, grfStatFlag);
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI ConfigStream_Clone(IStream *iface, IStream **ppstm)
 197 {
 198     ConfigStream *This = impl_from_IStream(iface);
 199     TRACE("(%p)\n",This);
 200     return E_NOTIMPL;
 201 }
 202
 203 static const IStreamVtbl ConfigStreamVtbl = {
 204   ConfigStream_QueryInterface,
 205   ConfigStream_AddRef,
 206   ConfigStream_Release,
 207   ConfigStream_Read,
 208   ConfigStream_Write,
 209   ConfigStream_Seek,
 210   ConfigStream_SetSize,
 211   ConfigStream_CopyTo,
 212   ConfigStream_Commit,
 213   ConfigStream_Revert,
 214   ConfigStream_LockUnlockRegion,
 215   ConfigStream_LockUnlockRegion,
 216   ConfigStream_Stat,
 217   ConfigStream_Clone
 218 };
 219
 220 HRESULT WINAPI CreateConfigStream(const WCHAR *filename, IStream **stream)
 221 {
 222     ConfigStream *config_stream;
 223     HANDLE file;
 224
 225     TRACE("(%s, %p)\n", debugstr_w(filename), stream);
 226
 227     if (!stream)
 228         return COR_E_NULLREFERENCE;
 229
 230     file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 231     if (file == INVALID_HANDLE_VALUE)
 232         return GetLastError() == ERROR_FILE_NOT_FOUND ? COR_E_FILENOTFOUND : E_FAIL;
 233
 234     config_stream = HeapAlloc(GetProcessHeap(), 0, sizeof(*config_stream));
 235     if (!config_stream)
 236     {
 237         CloseHandle(file);
 238         return E_OUTOFMEMORY;
 239     }
 240
 241     config_stream->IStream_iface.lpVtbl = &ConfigStreamVtbl;
 242     config_stream->ref = 1;
 243     config_stream->file = file;
 244
 245     *stream = &config_stream->IStream_iface;
 246     return S_OK;
 247 }
 248
 249 static inline ConfigFileHandler *impl_from_ISAXContentHandler(ISAXContentHandler *iface)
 250 {
 251     return CONTAINING_RECORD(iface, ConfigFileHandler, ISAXContentHandler_iface);
 252 }
 253
 254 static inline ConfigFileHandler *impl_from_ISAXErrorHandler(ISAXErrorHandler *iface)
 255 {
 256     return CONTAINING_RECORD(iface, ConfigFileHandler, ISAXErrorHandler_iface);
 257 }
 258
 259 static HRESULT WINAPI ConfigFileHandler_QueryInterface(ISAXContentHandler *iface,
 260     REFIID riid, void **ppvObject)
 261 {
 262     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 263
 264     if (IsEqualGUID(riid, &IID_ISAXContentHandler) || IsEqualGUID(riid, &IID_IUnknown))
 265         *ppvObject = &This->ISAXContentHandler_iface;
 266     else if (IsEqualGUID(riid, &IID_ISAXErrorHandler))
 267         *ppvObject = &This->ISAXErrorHandler_iface;
 268     else
 269     {
 270         WARN("Unsupported interface %s\n", debugstr_guid(riid));
 271         return E_NOINTERFACE;
 272     }
 273
 274     IUnknown_AddRef((IUnknown*)*ppvObject);
 275
 276     return S_OK;
 277 }
 278
 279 static ULONG WINAPI ConfigFileHandler_AddRef(ISAXContentHandler *iface)
 280 {
 281     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 282     return InterlockedIncrement(&This->ref);
 283 }
 284
 285 static ULONG WINAPI ConfigFileHandler_Release(ISAXContentHandler *iface)
 286 {
 287     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 288     ULONG ref = InterlockedDecrement(&This->ref);
 289
 290     if (ref == 0)
 291         HeapFree(GetProcessHeap(), 0, This);
 292
 293     return ref;
 294 }
 295
 296 static HRESULT WINAPI ConfigFileHandler_putDocumentLocator(ISAXContentHandler *iface,
 297     ISAXLocator *pLocator)
 298 {
 299     return S_OK;
 300 }
 301
 302 static HRESULT WINAPI ConfigFileHandler_startDocument(ISAXContentHandler *iface)
 303 {
 304     return S_OK;
 305 }
 306
 307 static HRESULT WINAPI ConfigFileHandler_endDocument(ISAXContentHandler *iface)
 308 {
 309     return S_OK;
 310 }
 311
 312 static HRESULT WINAPI ConfigFileHandler_startPrefixMapping(ISAXContentHandler *iface,
 313     const WCHAR *pPrefix, int nPrefix, const WCHAR *pUri, int nUri)
 314 {
 315     return S_OK;
 316 }
 317
 318 static HRESULT WINAPI ConfigFileHandler_endPrefixMapping(ISAXContentHandler *iface,
 319     const WCHAR *pPrefix, int nPrefix)
 320 {
 321     return S_OK;
 322 }
 323
 324 static HRESULT parse_startup(ConfigFileHandler *This, ISAXAttributes *pAttr)
 325 {
 326     static const WCHAR legacy[] = {'u','s','e','L','e','g','a','c','y','V','2','R','u','n','t','i','m','e','A','c','t','i','v','a','t','i','o','n','P','o','l','i','c','y',0};
 327     static const WCHAR empty[] = {0};
 328     LPCWSTR value;
 329     int value_size;
 330     HRESULT hr;
 331
 332     hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, legacy, lstrlenW(legacy), &value, &value_size);
 333     if (SUCCEEDED(hr))
 334         FIXME("useLegacyV2RuntimeActivationPolicy=%s not implemented\n", debugstr_wn(value, value_size));
 335     hr = S_OK;
 336
 337     return hr;
 338 }
 339
 340 static HRESULT parse_probing(ConfigFileHandler *This, ISAXAttributes *pAttr)
 341 {
 342     static const WCHAR privatePath[] = {'p','r','i','v','a','t','e','P','a','t','h',0};
 343     static const WCHAR empty[] = {0};
 344     LPCWSTR value;
 345     int value_size;
 346     HRESULT hr;
 347
 348     hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, privatePath, lstrlenW(privatePath), &value, &value_size);
 349     if (SUCCEEDED(hr))
 350     {
 351         TRACE("%s\n", debugstr_wn(value, value_size));
 352
 353         This->result->private_path = HeapAlloc(GetProcessHeap(), 0, (value_size + 1) * sizeof(WCHAR));
 354         if (This->result->private_path)
 355             wcscpy(This->result->private_path, value);
 356         else
 357             hr = E_OUTOFMEMORY;
 358     }
 359
 360     return hr;
 361 }
 362
 363
 364 static HRESULT parse_supported_runtime(ConfigFileHandler *This, ISAXAttributes *pAttr)
 365 {
 366     static const WCHAR version[] = {'v','e','r','s','i','o','n',0};
 367     static const WCHAR sku[] = {'s','k','u',0};
 368     static const WCHAR empty[] = {0};
 369     LPCWSTR value;
 370     int value_size;
 371     HRESULT hr;
 372     supported_runtime *entry;
 373
 374     hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, version, lstrlenW(version), &value, &value_size);
 375     if (SUCCEEDED(hr))
 376     {
 377         TRACE("%s\n", debugstr_wn(value, value_size));
 378         entry = HeapAlloc(GetProcessHeap(), 0, sizeof(supported_runtime));
 379         if (entry)
 380         {
 381             entry->version = HeapAlloc(GetProcessHeap(), 0, (value_size + 1) * sizeof(WCHAR));
 382             if (entry->version)
 383             {
 384                 lstrcpyW(entry->version, value);
 385                 list_add_tail(&This->result->supported_runtimes, &entry->entry);
 386             }
 387             else
 388             {
 389                 HeapFree(GetProcessHeap(), 0, entry);
 390                 hr = E_OUTOFMEMORY;
 391             }
 392         }
 393         else
 394             hr = E_OUTOFMEMORY;
 395     }
 396     else
 397         WARN("Missing version attribute\n");
 398
 399     if (SUCCEEDED(hr))
 400     {
 401         hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, sku, lstrlenW(sku), &value, &value_size);
 402         if (SUCCEEDED(hr))
 403             FIXME("sku=%s not implemented\n", debugstr_wn(value, value_size));
 404         hr = S_OK;
 405     }
 406
 407     return hr;
 408 }
 409
 410 static HRESULT WINAPI ConfigFileHandler_startElement(ISAXContentHandler *iface,
 411     const WCHAR *pNamespaceUri, int nNamespaceUri, const WCHAR *pLocalName,
 412     int nLocalName, const WCHAR *pQName, int nQName, ISAXAttributes *pAttr)
 413 {
 414     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 415     static const WCHAR configuration[] = {'c','o','n','f','i','g','u','r','a','t','i','o','n',0};
 416     static const WCHAR assemblyBinding[] = {'a','s','s','e','m','b','l','y','B','i','n','d','i','n','g',0};
 417     static const WCHAR probing[] = {'p','r','o','b','i','n','g',0};
 418     static const WCHAR runtime[] = {'r','u','n','t','i','m','e',0};
 419     static const WCHAR startup[] = {'s','t','a','r','t','u','p',0};
 420     static const WCHAR supportedRuntime[] = {'s','u','p','p','o','r','t','e','d','R','u','n','t','i','m','e',0};
 421
 422     HRESULT hr = S_OK;
 423
 424     TRACE("%s %s %s\n", debugstr_wn(pNamespaceUri,nNamespaceUri),
 425         debugstr_wn(pLocalName,nLocalName), debugstr_wn(pQName,nQName));
 426
 427     if (This->statenum == ARRAY_SIZE(This->states) - 1)
 428     {
 429         ERR("file has too much nesting\n");
 430         return E_FAIL;
 431     }
 432
 433     switch (This->states[This->statenum])
 434     {
 435     case STATE_ROOT:
 436         if (nLocalName == ARRAY_SIZE(configuration) - 1 && wcscmp(pLocalName, configuration) == 0)
 437         {
 438             This->states[++This->statenum] = STATE_CONFIGURATION;
 439             break;
 440         }
 441         else
 442             goto unknown;
 443     case STATE_CONFIGURATION:
 444         if (nLocalName == ARRAY_SIZE(startup) - 1 && wcscmp(pLocalName, startup) == 0)
 445         {
 446             hr = parse_startup(This, pAttr);
 447             This->states[++This->statenum] = STATE_STARTUP;
 448             break;
 449         }
 450         else if (nLocalName == ARRAY_SIZE(runtime) - 1 && wcscmp(pLocalName, runtime) == 0)
 451         {
 452             This->states[++This->statenum] = STATE_RUNTIME;
 453             break;
 454         }
 455         else
 456             goto unknown;
 457     case STATE_RUNTIME:
 458         if (nLocalName == ARRAY_SIZE(assemblyBinding) - 1 &&
 459             wcscmp(pLocalName, assemblyBinding) == 0)
 460         {
 461             This->states[++This->statenum] = STATE_ASSEMBLY_BINDING;
 462             break;
 463         }
 464         else
 465             goto unknown;
 466     case STATE_ASSEMBLY_BINDING:
 467         if (nLocalName == ARRAY_SIZE(probing) - 1 && wcscmp(pLocalName, probing) == 0)
 468         {
 469             hr = parse_probing(This, pAttr);
 470             This->states[++This->statenum] = STATE_PROBING;
 471             break;
 472         }
 473         else
 474             goto unknown;
 475     case STATE_STARTUP:
 476         if (nLocalName == ARRAY_SIZE(supportedRuntime) - 1 &&
 477             wcscmp(pLocalName, supportedRuntime) == 0)
 478         {
 479             hr = parse_supported_runtime(This, pAttr);
 480             This->states[++This->statenum] = STATE_UNKNOWN;
 481             break;
 482         }
 483         else
 484             goto unknown;
 485     default:
 486         goto unknown;
 487     }
 488
 489     return hr;
 490
 491 unknown:
 492     TRACE("Unknown element %s in state %u\n", debugstr_wn(pLocalName,nLocalName),
 493         This->states[This->statenum]);
 494
 495     This->states[++This->statenum] = STATE_UNKNOWN;
 496
 497     return S_OK;
 498 }
 499
 500 static HRESULT WINAPI ConfigFileHandler_endElement(ISAXContentHandler *iface,
 501     const WCHAR *pNamespaceUri, int nNamespaceUri, const WCHAR *pLocalName,
 502     int nLocalName, const WCHAR *pQName, int nQName)
 503 {
 504     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 505
 506     TRACE("%s %s %s\n", debugstr_wn(pNamespaceUri,nNamespaceUri),
 507         debugstr_wn(pLocalName,nLocalName), debugstr_wn(pQName,nQName));
 508
 509     if (This->statenum > 0)
 510     {
 511         This->statenum--;
 512     }
 513     else
 514     {
 515         ERR("element end does not match a start\n");
 516         return E_FAIL;
 517     }
 518
 519     return S_OK;
 520 }
 521
 522 static HRESULT WINAPI ConfigFileHandler_characters(ISAXContentHandler *iface,
 523     const WCHAR *pChars, int nChars)
 524 {
 525     TRACE("%s\n", debugstr_wn(pChars,nChars));
 526
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI ConfigFileHandler_ignorableWhitespace(ISAXContentHandler *iface,
 531     const WCHAR *pChars, int nChars)
 532 {
 533     return S_OK;
 534 }
 535
 536 static HRESULT WINAPI ConfigFileHandler_processingInstruction(ISAXContentHandler *iface,
 537     const WCHAR *pTarget, int nTarget, const WCHAR *pData, int nData)
 538 {
 539     return S_OK;
 540 }
 541
 542 static HRESULT WINAPI ConfigFileHandler_skippedEntity(ISAXContentHandler *iface,
 543     const WCHAR * pName, int nName)
 544 {
 545     TRACE("%s\n", debugstr_wn(pName,nName));
 546     return S_OK;
 547 }
 548
 549 static const struct ISAXContentHandlerVtbl ConfigFileHandlerVtbl =
 550 {
 551     ConfigFileHandler_QueryInterface,
 552     ConfigFileHandler_AddRef,
 553     ConfigFileHandler_Release,
 554     ConfigFileHandler_putDocumentLocator,
 555     ConfigFileHandler_startDocument,
 556     ConfigFileHandler_endDocument,
 557     ConfigFileHandler_startPrefixMapping,
 558     ConfigFileHandler_endPrefixMapping,
 559     ConfigFileHandler_startElement,
 560     ConfigFileHandler_endElement,
 561     ConfigFileHandler_characters,
 562     ConfigFileHandler_ignorableWhitespace,
 563     ConfigFileHandler_processingInstruction,
 564     ConfigFileHandler_skippedEntity
 565 };
 566
 567 static HRESULT WINAPI ConfigFileHandler_Error_QueryInterface(ISAXErrorHandler *iface,
 568     REFIID riid, void **ppvObject)
 569 {
 570     ConfigFileHandler *This = impl_from_ISAXErrorHandler(iface);
 571     return ISAXContentHandler_QueryInterface(&This->ISAXContentHandler_iface, riid, ppvObject);
 572 }
 573
 574 static ULONG WINAPI ConfigFileHandler_Error_AddRef(ISAXErrorHandler *iface)
 575 {
 576     ConfigFileHandler *This = impl_from_ISAXErrorHandler(iface);
 577     return ISAXContentHandler_AddRef(&This->ISAXContentHandler_iface);
 578 }
 579
 580 static ULONG WINAPI ConfigFileHandler_Error_Release(ISAXErrorHandler *iface)
 581 {
 582     ConfigFileHandler *This = impl_from_ISAXErrorHandler(iface);
 583     return ISAXContentHandler_Release(&This->ISAXContentHandler_iface);
 584 }
 585
 586 static HRESULT WINAPI ConfigFileHandler_error(ISAXErrorHandler *iface,
 587     ISAXLocator * pLocator, const WCHAR * pErrorMessage, HRESULT hrErrorCode)
 588 {
 589     WARN("%s,%x\n", debugstr_w(pErrorMessage), hrErrorCode);
 590     return S_OK;
 591 }
 592
 593 static HRESULT WINAPI ConfigFileHandler_fatalError(ISAXErrorHandler *iface,
 594     ISAXLocator * pLocator, const WCHAR * pErrorMessage, HRESULT hrErrorCode)
 595 {
 596     WARN("%s,%x\n", debugstr_w(pErrorMessage), hrErrorCode);
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI ConfigFileHandler_ignorableWarning(ISAXErrorHandler *iface,
 601     ISAXLocator * pLocator, const WCHAR * pErrorMessage, HRESULT hrErrorCode)
 602 {
 603     WARN("%s,%x\n", debugstr_w(pErrorMessage), hrErrorCode);
 604     return S_OK;
 605 }
 606
 607 static const struct ISAXErrorHandlerVtbl ConfigFileHandlerErrorVtbl =
 608 {
 609     ConfigFileHandler_Error_QueryInterface,
 610     ConfigFileHandler_Error_AddRef,
 611     ConfigFileHandler_Error_Release,
 612     ConfigFileHandler_error,
 613     ConfigFileHandler_fatalError,
 614     ConfigFileHandler_ignorableWarning
 615 };
 616
 617 static void init_config(parsed_config_file *config)
 618 {
 619     list_init(&config->supported_runtimes);
 620 }
 621
 622 static HRESULT parse_config(VARIANT input, parsed_config_file *result)
 623 {
 624     ISAXXMLReader *reader;
 625     ConfigFileHandler *handler;
 626     HRESULT hr;
 627
 628     handler = HeapAlloc(GetProcessHeap(), 0, sizeof(ConfigFileHandler));
 629     if (!handler)
 630         return E_OUTOFMEMORY;
 631
 632     handler->ISAXContentHandler_iface.lpVtbl = &ConfigFileHandlerVtbl;
 633     handler->ISAXErrorHandler_iface.lpVtbl = &ConfigFileHandlerErrorVtbl;
 634     handler->ref = 1;
 635     handler->states[0] = STATE_ROOT;
 636     handler->statenum = 0;
 637     handler->result = result;
 638
 639     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
 640         &IID_ISAXXMLReader, (LPVOID*)&reader);
 641
 642     if (SUCCEEDED(hr))
 643     {
 644         hr = ISAXXMLReader_putContentHandler(reader, &handler->ISAXContentHandler_iface);
 645
 646         if (SUCCEEDED(hr))
 647             hr = ISAXXMLReader_putErrorHandler(reader, &handler->ISAXErrorHandler_iface);
 648
 649         if (SUCCEEDED(hr))
 650             hr = ISAXXMLReader_parse(reader, input);
 651
 652         ISAXXMLReader_Release(reader);
 653     }
 654
 655     ISAXContentHandler_Release(&handler->ISAXContentHandler_iface);
 656
 657     return S_OK;
 658 }
 659
 660 HRESULT parse_config_stream(IStream *stream, parsed_config_file *result)
 661 {
 662     VARIANT var;
 663     HRESULT hr;
 664     HRESULT initresult;
 665
 666     init_config(result);
 667
 668     initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 669     V_VT(&var) = VT_UNKNOWN;
 670     V_UNKNOWN(&var) = (IUnknown*)stream;
 671
 672     hr = parse_config(var, result);
 673
 674     if (SUCCEEDED(initresult))
 675         CoUninitialize();
 676
 677     return hr;
 678 }
 679
 680 HRESULT parse_config_file(LPCWSTR filename, parsed_config_file *result)
 681 {
 682     HRESULT hr;
 683     IStream *stream;
 684
 685     init_config(result);
 686
 687     hr = CreateConfigStream(filename, &stream);
 688     if (FAILED(hr))
 689         return hr;
 690
 691     hr = parse_config_stream(stream, result);
 692
 693     IStream_Release(stream);
 694
 695     return hr;
 696 }
 697
 698 void free_parsed_config_file(parsed_config_file *file)
 699 {
 700     supported_runtime *cursor, *cursor2;
 701
 702     LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &file->supported_runtimes, supported_runtime, entry)
 703     {
 704         HeapFree(GetProcessHeap(), 0, cursor->version);
 705         list_remove(&cursor->entry);
 706         HeapFree(GetProcessHeap(), 0, cursor);
 707     }
 708
 709     HeapFree(GetProcessHeap(), 0, file->private_path);
 710 }