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