dll/win32/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 #include "mscoree_private.h"
  22
  23 #include <ole2.h>
  24 #include <shlwapi.h>
  25 #include <initguid.h>
  26 #include <msxml2.h>
  27
  28 enum parse_state
  29 {
  30     STATE_ROOT,
  31     STATE_CONFIGURATION,
  32     STATE_STARTUP,
  33     STATE_UNKNOWN
  34 };
  35
  36 typedef struct ConfigFileHandler
  37 {
  38     ISAXContentHandler ISAXContentHandler_iface;
  39     ISAXErrorHandler ISAXErrorHandler_iface;
  40     LONG ref;
  41     enum parse_state states[16];
  42     int statenum;
  43     parsed_config_file *result;
  44 } ConfigFileHandler;
  45
  46 static inline ConfigFileHandler *impl_from_ISAXContentHandler(ISAXContentHandler *iface)
  47 {
  48     return CONTAINING_RECORD(iface, ConfigFileHandler, ISAXContentHandler_iface);
  49 }
  50
  51 static inline ConfigFileHandler *impl_from_ISAXErrorHandler(ISAXErrorHandler *iface)
  52 {
  53     return CONTAINING_RECORD(iface, ConfigFileHandler, ISAXErrorHandler_iface);
  54 }
  55
  56 static HRESULT WINAPI ConfigFileHandler_QueryInterface(ISAXContentHandler *iface,
  57     REFIID riid, void **ppvObject)
  58 {
  59     if (IsEqualGUID(riid, &IID_ISAXContentHandler) ||
  60         IsEqualGUID(riid, &IID_IUnknown))
  61     {
  62         *ppvObject = iface;
  63     }
  64     else
  65     {
  66         WARN("Unsupported interface %s\n", debugstr_guid(riid));
  67         return E_NOINTERFACE;
  68     }
  69
  70     ISAXContentHandler_AddRef(iface);
  71
  72     return S_OK;
  73 }
  74
  75 static ULONG WINAPI ConfigFileHandler_AddRef(ISAXContentHandler *iface)
  76 {
  77     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
  78     return InterlockedIncrement(&This->ref);
  79 }
  80
  81 static ULONG WINAPI ConfigFileHandler_Release(ISAXContentHandler *iface)
  82 {
  83     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
  84     ULONG ref = InterlockedDecrement(&This->ref);
  85
  86     if (ref == 0)
  87         HeapFree(GetProcessHeap(), 0, This);
  88
  89     return ref;
  90 }
  91
  92 static HRESULT WINAPI ConfigFileHandler_putDocumentLocator(ISAXContentHandler *iface,
  93     ISAXLocator *pLocator)
  94 {
  95     return S_OK;
  96 }
  97
  98 static HRESULT WINAPI ConfigFileHandler_startDocument(ISAXContentHandler *iface)
  99 {
 100     return S_OK;
 101 }
 102
 103 static HRESULT WINAPI ConfigFileHandler_endDocument(ISAXContentHandler *iface)
 104 {
 105     return S_OK;
 106 }
 107
 108 static HRESULT WINAPI ConfigFileHandler_startPrefixMapping(ISAXContentHandler *iface,
 109     const WCHAR *pPrefix, int nPrefix, const WCHAR *pUri, int nUri)
 110 {
 111     return S_OK;
 112 }
 113
 114 static HRESULT WINAPI ConfigFileHandler_endPrefixMapping(ISAXContentHandler *iface,
 115     const WCHAR *pPrefix, int nPrefix)
 116 {
 117     return S_OK;
 118 }
 119
 120 static HRESULT parse_startup(ConfigFileHandler *This, ISAXAttributes *pAttr)
 121 {
 122     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};
 123     static const WCHAR empty[] = {0};
 124     LPCWSTR value;
 125     int value_size;
 126     HRESULT hr;
 127
 128     hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, legacy, lstrlenW(legacy), &value, &value_size);
 129     if (SUCCEEDED(hr))
 130         FIXME("useLegacyV2RuntimeActivationPolicy=%s not implemented\n", debugstr_wn(value, value_size));
 131     hr = S_OK;
 132
 133     return hr;
 134 }
 135
 136 static HRESULT parse_supported_runtime(ConfigFileHandler *This, ISAXAttributes *pAttr)
 137 {
 138     static const WCHAR version[] = {'v','e','r','s','i','o','n',0};
 139     static const WCHAR sku[] = {'s','k','u',0};
 140     static const WCHAR empty[] = {0};
 141     LPCWSTR value;
 142     int value_size;
 143     HRESULT hr;
 144     supported_runtime *entry;
 145
 146     hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, version, lstrlenW(version), &value, &value_size);
 147     if (SUCCEEDED(hr))
 148     {
 149         TRACE("%s\n", debugstr_wn(value, value_size));
 150         entry = HeapAlloc(GetProcessHeap(), 0, sizeof(supported_runtime));
 151         if (entry)
 152         {
 153             entry->version = HeapAlloc(GetProcessHeap(), 0, (value_size + 1) * sizeof(WCHAR));
 154             if (entry->version)
 155             {
 156                 lstrcpyW(entry->version, value);
 157                 list_add_tail(&This->result->supported_runtimes, &entry->entry);
 158             }
 159             else
 160             {
 161                 HeapFree(GetProcessHeap(), 0, entry);
 162                 hr = E_OUTOFMEMORY;
 163             }
 164         }
 165         else
 166             hr = E_OUTOFMEMORY;
 167     }
 168     else
 169         WARN("Missing version attribute\n");
 170
 171     if (SUCCEEDED(hr))
 172     {
 173         hr = ISAXAttributes_getValueFromName(pAttr, empty, 0, sku, lstrlenW(sku), &value, &value_size);
 174         if (SUCCEEDED(hr))
 175             FIXME("sku=%s not implemented\n", debugstr_wn(value, value_size));
 176         hr = S_OK;
 177     }
 178
 179     return hr;
 180 }
 181
 182 static HRESULT WINAPI ConfigFileHandler_startElement(ISAXContentHandler *iface,
 183     const WCHAR *pNamespaceUri, int nNamespaceUri, const WCHAR *pLocalName,
 184     int nLocalName, const WCHAR *pQName, int nQName, ISAXAttributes *pAttr)
 185 {
 186     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 187     static const WCHAR configuration[] = {'c','o','n','f','i','g','u','r','a','t','i','o','n',0};
 188     static const WCHAR startup[] = {'s','t','a','r','t','u','p',0};
 189     static const WCHAR supportedRuntime[] = {'s','u','p','p','o','r','t','e','d','R','u','n','t','i','m','e',0};
 190     HRESULT hr = S_OK;
 191
 192     TRACE("%s %s %s\n", debugstr_wn(pNamespaceUri,nNamespaceUri),
 193         debugstr_wn(pLocalName,nLocalName), debugstr_wn(pQName,nQName));
 194
 195     if (This->statenum == sizeof(This->states) / sizeof(This->states[0]) - 1)
 196     {
 197         ERR("file has too much nesting\n");
 198         return E_FAIL;
 199     }
 200
 201     switch (This->states[This->statenum])
 202     {
 203     case STATE_ROOT:
 204         if (nLocalName == sizeof(configuration)/sizeof(WCHAR)-1 &&
 205             lstrcmpW(pLocalName, configuration) == 0)
 206         {
 207             This->states[++This->statenum] = STATE_CONFIGURATION;
 208             break;
 209         }
 210         else
 211             goto unknown;
 212     case STATE_CONFIGURATION:
 213         if (nLocalName == sizeof(startup)/sizeof(WCHAR)-1 &&
 214             lstrcmpW(pLocalName, startup) == 0)
 215         {
 216             hr = parse_startup(This, pAttr);
 217             This->states[++This->statenum] = STATE_STARTUP;
 218             break;
 219         }
 220         else
 221             goto unknown;
 222     case STATE_STARTUP:
 223         if (nLocalName == sizeof(supportedRuntime)/sizeof(WCHAR)-1 &&
 224             lstrcmpW(pLocalName, supportedRuntime) == 0)
 225         {
 226             hr = parse_supported_runtime(This, pAttr);
 227             This->states[++This->statenum] = STATE_UNKNOWN;
 228             break;
 229         }
 230         else
 231             goto unknown;
 232     default:
 233         goto unknown;
 234     }
 235
 236     return hr;
 237
 238 unknown:
 239     FIXME("Unknown element %s in state %u\n", debugstr_wn(pLocalName,nLocalName),
 240         This->states[This->statenum]);
 241
 242     This->states[++This->statenum] = STATE_UNKNOWN;
 243
 244     return S_OK;
 245 }
 246
 247 static HRESULT WINAPI ConfigFileHandler_endElement(ISAXContentHandler *iface,
 248     const WCHAR *pNamespaceUri, int nNamespaceUri, const WCHAR *pLocalName,
 249     int nLocalName, const WCHAR *pQName, int nQName)
 250 {
 251     ConfigFileHandler *This = impl_from_ISAXContentHandler(iface);
 252
 253     TRACE("%s %s %s\n", debugstr_wn(pNamespaceUri,nNamespaceUri),
 254         debugstr_wn(pLocalName,nLocalName), debugstr_wn(pQName,nQName));
 255
 256     if (This->statenum > 0)
 257     {
 258         This->statenum--;
 259     }
 260     else
 261     {
 262         ERR("element end does not match a start\n");
 263         return E_FAIL;
 264     }
 265
 266     return S_OK;
 267 }
 268
 269 static HRESULT WINAPI ConfigFileHandler_characters(ISAXContentHandler *iface,
 270     const WCHAR *pChars, int nChars)
 271 {
 272     TRACE("%s\n", debugstr_wn(pChars,nChars));
 273
 274     return S_OK;
 275 }
 276
 277 static HRESULT WINAPI ConfigFileHandler_ignorableWhitespace(ISAXContentHandler *iface,
 278     const WCHAR *pChars, int nChars)
 279 {
 280     return S_OK;
 281 }
 282
 283 static HRESULT WINAPI ConfigFileHandler_processingInstruction(ISAXContentHandler *iface,
 284     const WCHAR *pTarget, int nTarget, const WCHAR *pData, int nData)
 285 {
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI ConfigFileHandler_skippedEntity(ISAXContentHandler *iface,
 290     const WCHAR * pName, int nName)
 291 {
 292     TRACE("%s\n", debugstr_wn(pName,nName));
 293     return S_OK;
 294 }
 295
 296 static const struct ISAXContentHandlerVtbl ConfigFileHandlerVtbl =
 297 {
 298     ConfigFileHandler_QueryInterface,
 299     ConfigFileHandler_AddRef,
 300     ConfigFileHandler_Release,
 301     ConfigFileHandler_putDocumentLocator,
 302     ConfigFileHandler_startDocument,
 303     ConfigFileHandler_endDocument,
 304     ConfigFileHandler_startPrefixMapping,
 305     ConfigFileHandler_endPrefixMapping,
 306     ConfigFileHandler_startElement,
 307     ConfigFileHandler_endElement,
 308     ConfigFileHandler_characters,
 309     ConfigFileHandler_ignorableWhitespace,
 310     ConfigFileHandler_processingInstruction,
 311     ConfigFileHandler_skippedEntity
 312 };
 313
 314 static HRESULT WINAPI ConfigFileHandler_Error_QueryInterface(ISAXErrorHandler *iface,
 315     REFIID riid, void **ppvObject)
 316 {
 317     if (IsEqualGUID(riid, &IID_ISAXErrorHandler) ||
 318         IsEqualGUID(riid, &IID_IUnknown))
 319     {
 320         *ppvObject = iface;
 321     }
 322     else
 323     {
 324         WARN("Unsupported interface %s\n", debugstr_guid(riid));
 325         return E_NOINTERFACE;
 326     }
 327
 328     ISAXErrorHandler_AddRef(iface);
 329
 330     return S_OK;
 331 }
 332
 333 static ULONG WINAPI ConfigFileHandler_Error_AddRef(ISAXErrorHandler *iface)
 334 {
 335     ConfigFileHandler *This = impl_from_ISAXErrorHandler(iface);
 336     return IUnknown_AddRef((IUnknown*)This);
 337 }
 338
 339 static ULONG WINAPI ConfigFileHandler_Error_Release(ISAXErrorHandler *iface)
 340 {
 341     ConfigFileHandler *This = impl_from_ISAXErrorHandler(iface);
 342     return IUnknown_Release((IUnknown*)This);
 343 }
 344
 345 static HRESULT WINAPI ConfigFileHandler_error(ISAXErrorHandler *iface,
 346     ISAXLocator * pLocator, const WCHAR * pErrorMessage, HRESULT hrErrorCode)
 347 {
 348     WARN("%s,%x\n", debugstr_w(pErrorMessage), hrErrorCode);
 349     return S_OK;
 350 }
 351
 352 static HRESULT WINAPI ConfigFileHandler_fatalError(ISAXErrorHandler *iface,
 353     ISAXLocator * pLocator, const WCHAR * pErrorMessage, HRESULT hrErrorCode)
 354 {
 355     WARN("%s,%x\n", debugstr_w(pErrorMessage), hrErrorCode);
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI ConfigFileHandler_ignorableWarning(ISAXErrorHandler *iface,
 360     ISAXLocator * pLocator, const WCHAR * pErrorMessage, HRESULT hrErrorCode)
 361 {
 362     WARN("%s,%x\n", debugstr_w(pErrorMessage), hrErrorCode);
 363     return S_OK;
 364 }
 365
 366 static const struct ISAXErrorHandlerVtbl ConfigFileHandlerErrorVtbl =
 367 {
 368     ConfigFileHandler_Error_QueryInterface,
 369     ConfigFileHandler_Error_AddRef,
 370     ConfigFileHandler_Error_Release,
 371     ConfigFileHandler_error,
 372     ConfigFileHandler_fatalError,
 373     ConfigFileHandler_ignorableWarning
 374 };
 375
 376 static void init_config(parsed_config_file *config)
 377 {
 378     list_init(&config->supported_runtimes);
 379 }
 380
 381 static HRESULT parse_config(VARIANT input, parsed_config_file *result)
 382 {
 383     ISAXXMLReader *reader;
 384     ConfigFileHandler *handler;
 385     HRESULT hr;
 386
 387     handler = HeapAlloc(GetProcessHeap(), 0, sizeof(ConfigFileHandler));
 388     if (!handler)
 389         return E_OUTOFMEMORY;
 390
 391     handler->ISAXContentHandler_iface.lpVtbl = &ConfigFileHandlerVtbl;
 392     handler->ISAXErrorHandler_iface.lpVtbl = &ConfigFileHandlerErrorVtbl;
 393     handler->ref = 1;
 394     handler->states[0] = STATE_ROOT;
 395     handler->statenum = 0;
 396     handler->result = result;
 397
 398     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
 399         &IID_ISAXXMLReader, (LPVOID*)&reader);
 400
 401     if (SUCCEEDED(hr))
 402     {
 403         hr = ISAXXMLReader_putContentHandler(reader, &handler->ISAXContentHandler_iface);
 404
 405         if (SUCCEEDED(hr))
 406             hr = ISAXXMLReader_putErrorHandler(reader, &handler->ISAXErrorHandler_iface);
 407
 408         if (SUCCEEDED(hr))
 409             hr = ISAXXMLReader_parse(reader, input);
 410
 411         ISAXXMLReader_Release(reader);
 412     }
 413
 414     ISAXContentHandler_Release(&handler->ISAXContentHandler_iface);
 415
 416     return S_OK;
 417 }
 418
 419 HRESULT parse_config_file(LPCWSTR filename, parsed_config_file *result)
 420 {
 421     IStream *stream;
 422     VARIANT var;
 423     HRESULT hr;
 424     HRESULT initresult;
 425
 426     init_config(result);
 427
 428     initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 429
 430     hr = SHCreateStreamOnFileW(filename, STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE, &stream);
 431
 432     if (SUCCEEDED(hr))
 433     {
 434         V_VT(&var) = VT_UNKNOWN;
 435         V_UNKNOWN(&var) = (IUnknown*)stream;
 436
 437         hr = parse_config(var, result);
 438
 439         IStream_Release(stream);
 440     }
 441
 442     if (SUCCEEDED(initresult))
 443         CoUninitialize();
 444
 445     return hr;
 446 }
 447
 448 void free_parsed_config_file(parsed_config_file *file)
 449 {
 450     supported_runtime *cursor, *cursor2;
 451
 452     LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &file->supported_runtimes, supported_runtime, entry)
 453     {
 454         HeapFree(GetProcessHeap(), 0, cursor->version);
 455         list_remove(&cursor->entry);
 456         HeapFree(GetProcessHeap(), 0, cursor);
 457     }
 458 }