dlls/mscoree/metahost.c

   1 /*
   2  * ICLRMetaHost - discovery and management of available .NET runtimes
   3  *
   4  * Copyright 2010 Vincent Povirk for CodeWeavers
   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 <stdio.h>
  22 #include <stdarg.h>
  23 #include <assert.h>
  24
  25 #define COBJMACROS
  26
  27 #include "wine/unicode.h"
  28 #include "wine/library.h"
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winreg.h"
  32 #include "ole2.h"
  33
  34 #include "corerror.h"
  35 #include "cor.h"
  36 #include "mscoree.h"
  37 #include "corhdr.h"
  38 #include "cordebug.h"
  39 #include "metahost.h"
  40 #include "fusion.h"
  41 #include "wine/list.h"
  42 #include "mscoree_private.h"
  43
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL( mscoree );
  47
  48 static const struct ICLRRuntimeInfoVtbl CLRRuntimeInfoVtbl;
  49
  50 #define NUM_RUNTIMES 4
  51
  52 static struct CLRRuntimeInfo runtimes[NUM_RUNTIMES] = {
  53     {{&CLRRuntimeInfoVtbl}, 1, 0, 3705, 0},
  54     {{&CLRRuntimeInfoVtbl}, 1, 1, 4322, 0},
  55     {{&CLRRuntimeInfoVtbl}, 2, 0, 50727, 0},
  56     {{&CLRRuntimeInfoVtbl}, 4, 0, 30319, 0}
  57 };
  58
  59 static CRITICAL_SECTION runtime_list_cs;
  60 static CRITICAL_SECTION_DEBUG runtime_list_cs_debug =
  61 {
  62     0, 0, &runtime_list_cs,
  63     { &runtime_list_cs_debug.ProcessLocksList,
  64       &runtime_list_cs_debug.ProcessLocksList },
  65       0, 0, { (DWORD_PTR)(__FILE__ ": runtime_list_cs") }
  66 };
  67 static CRITICAL_SECTION runtime_list_cs = { &runtime_list_cs_debug, -1, 0, 0, 0, 0 };
  68
  69 static HMODULE mono_handle;
  70
  71 BOOL is_mono_started;
  72 static BOOL is_mono_shutdown;
  73
  74 MonoImage* (CDECL *mono_assembly_get_image)(MonoAssembly *assembly);
  75 MonoAssembly* (CDECL *mono_assembly_load_from)(MonoImage *image, const char *fname, MonoImageOpenStatus *status);
  76 MonoAssembly* (CDECL *mono_assembly_open)(const char *filename, MonoImageOpenStatus *status);
  77 MonoClass* (CDECL *mono_class_from_mono_type)(MonoType *type);
  78 MonoClass* (CDECL *mono_class_from_name)(MonoImage *image, const char* name_space, const char *name);
  79 MonoMethod* (CDECL *mono_class_get_method_from_name)(MonoClass *klass, const char *name, int param_count);
  80 static void (CDECL *mono_config_parse)(const char *filename);
  81 MonoAssembly* (CDECL *mono_domain_assembly_open)(MonoDomain *domain, const char *name);
  82 static void (CDECL *mono_free)(void *);
  83 static MonoImage* (CDECL *mono_image_open)(const char *fname, MonoImageOpenStatus *status);
  84 MonoImage* (CDECL *mono_image_open_from_module_handle)(HMODULE module_handle, char* fname, UINT has_entry_point, MonoImageOpenStatus* status);
  85 static void (CDECL *mono_install_assembly_preload_hook)(MonoAssemblyPreLoadFunc func, void *user_data);
  86 int (CDECL *mono_jit_exec)(MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]);
  87 MonoDomain* (CDECL *mono_jit_init_version)(const char *domain_name, const char *runtime_version);
  88 static int (CDECL *mono_jit_set_trace_options)(const char* options);
  89 void* (CDECL *mono_marshal_get_vtfixup_ftnptr)(MonoImage *image, DWORD token, WORD type);
  90 MonoDomain* (CDECL *mono_object_get_domain)(MonoObject *obj);
  91 MonoObject* (CDECL *mono_object_new)(MonoDomain *domain, MonoClass *klass);
  92 void* (CDECL *mono_object_unbox)(MonoObject *obj);
  93 static void (CDECL *mono_profiler_install)(MonoProfiler *prof, MonoProfileFunc shutdown_callback);
  94 MonoType* (CDECL *mono_reflection_type_from_name)(char *name, MonoImage *image);
  95 MonoObject* (CDECL *mono_runtime_invoke)(MonoMethod *method, void *obj, void **params, MonoObject **exc);
  96 void (CDECL *mono_runtime_object_init)(MonoObject *this_obj);
  97 void (CDECL *mono_runtime_quit)(void);
  98 static void (CDECL *mono_set_dirs)(const char *assembly_dir, const char *config_dir);
  99 static void (CDECL *mono_set_verbose_level)(DWORD level);
 100 MonoString* (CDECL *mono_string_new)(MonoDomain *domain, const char *str);
 101 static char* (CDECL *mono_stringify_assembly_name)(MonoAssemblyName *aname);
 102 MonoThread* (CDECL *mono_thread_attach)(MonoDomain *domain);
 103 void (CDECL *mono_thread_manage)(void);
 104 void (CDECL *mono_trace_set_assembly)(MonoAssembly *assembly);
 105 void (CDECL *mono_trace_set_print_handler)(MonoPrintCallback callback);
 106 void (CDECL *mono_trace_set_printerr_handler)(MonoPrintCallback callback);
 107
 108 static BOOL get_mono_path(LPWSTR path);
 109
 110 static BOOL find_mono_dll(LPCWSTR path, LPWSTR dll_path);
 111
 112 static MonoAssembly* mono_assembly_preload_hook_fn(MonoAssemblyName *aname, char **assemblies_path, void *user_data);
 113
 114 static void mono_shutdown_callback_fn(MonoProfiler *prof);
 115
 116 static void mono_print_handler_fn(const char *string, INT is_stdout);
 117
 118 static MonoImage* CDECL image_open_module_handle_dummy(HMODULE module_handle,
 119     char* fname, UINT has_entry_point, MonoImageOpenStatus* status)
 120 {
 121     return mono_image_open(fname, status);
 122 }
 123
 124 static void CDECL set_print_handler_dummy(MonoPrintCallback callback)
 125 {
 126 }
 127
 128 static void missing_runtime_message(void)
 129 {
 130     MESSAGE("wine: Install Mono for Windows to run .NET applications.\n");
 131 }
 132
 133 static HRESULT load_mono(LPCWSTR mono_path)
 134 {
 135     static const WCHAR lib[] = {'\\','l','i','b',0};
 136     static const WCHAR etc[] = {'\\','e','t','c',0};
 137     WCHAR mono_dll_path[MAX_PATH+16];
 138     WCHAR mono_lib_path[MAX_PATH+4], mono_etc_path[MAX_PATH+4];
 139     char mono_lib_path_a[MAX_PATH], mono_etc_path_a[MAX_PATH];
 140     int trace_size;
 141     char trace_setting[256];
 142     int verbose_size;
 143     char verbose_setting[256];
 144
 145     if (is_mono_shutdown)
 146     {
 147         ERR("Cannot load Mono after it has been shut down.\n");
 148         return E_FAIL;
 149     }
 150
 151     if (!mono_handle)
 152     {
 153         strcpyW(mono_lib_path, mono_path);
 154         strcatW(mono_lib_path, lib);
 155         WideCharToMultiByte(CP_UTF8, 0, mono_lib_path, -1, mono_lib_path_a, MAX_PATH, NULL, NULL);
 156
 157         strcpyW(mono_etc_path, mono_path);
 158         strcatW(mono_etc_path, etc);
 159         WideCharToMultiByte(CP_UTF8, 0, mono_etc_path, -1, mono_etc_path_a, MAX_PATH, NULL, NULL);
 160
 161         if (!find_mono_dll(mono_path, mono_dll_path)) goto fail;
 162
 163         mono_handle = LoadLibraryW(mono_dll_path);
 164
 165         if (!mono_handle) goto fail;
 166
 167 #define LOAD_MONO_FUNCTION(x) do { \
 168     x = (void*)GetProcAddress(mono_handle, #x); \
 169     if (!x) { \
 170         goto fail; \
 171     } \
 172 } while (0);
 173
 174         LOAD_MONO_FUNCTION(mono_assembly_get_image);
 175         LOAD_MONO_FUNCTION(mono_assembly_load_from);
 176         LOAD_MONO_FUNCTION(mono_assembly_open);
 177         LOAD_MONO_FUNCTION(mono_config_parse);
 178         LOAD_MONO_FUNCTION(mono_class_from_mono_type);
 179         LOAD_MONO_FUNCTION(mono_class_from_name);
 180         LOAD_MONO_FUNCTION(mono_class_get_method_from_name);
 181         LOAD_MONO_FUNCTION(mono_domain_assembly_open);
 182         LOAD_MONO_FUNCTION(mono_free);
 183         LOAD_MONO_FUNCTION(mono_image_open);
 184         LOAD_MONO_FUNCTION(mono_install_assembly_preload_hook);
 185         LOAD_MONO_FUNCTION(mono_jit_exec);
 186         LOAD_MONO_FUNCTION(mono_jit_init_version);
 187         LOAD_MONO_FUNCTION(mono_jit_set_trace_options);
 188         LOAD_MONO_FUNCTION(mono_marshal_get_vtfixup_ftnptr);
 189         LOAD_MONO_FUNCTION(mono_object_get_domain);
 190         LOAD_MONO_FUNCTION(mono_object_new);
 191         LOAD_MONO_FUNCTION(mono_object_unbox);
 192         LOAD_MONO_FUNCTION(mono_profiler_install);
 193         LOAD_MONO_FUNCTION(mono_reflection_type_from_name);
 194         LOAD_MONO_FUNCTION(mono_runtime_invoke);
 195         LOAD_MONO_FUNCTION(mono_runtime_object_init);
 196         LOAD_MONO_FUNCTION(mono_runtime_quit);
 197         LOAD_MONO_FUNCTION(mono_set_dirs);
 198         LOAD_MONO_FUNCTION(mono_set_verbose_level);
 199         LOAD_MONO_FUNCTION(mono_stringify_assembly_name);
 200         LOAD_MONO_FUNCTION(mono_string_new);
 201         LOAD_MONO_FUNCTION(mono_thread_attach);
 202         LOAD_MONO_FUNCTION(mono_thread_manage);
 203         LOAD_MONO_FUNCTION(mono_trace_set_assembly);
 204
 205 #undef LOAD_MONO_FUNCTION
 206
 207 #define LOAD_OPT_MONO_FUNCTION(x, default) do { \
 208     x = (void*)GetProcAddress(mono_handle, #x); \
 209     if (!x) { \
 210         x = default; \
 211     } \
 212 } while (0);
 213
 214         LOAD_OPT_MONO_FUNCTION(mono_image_open_from_module_handle, image_open_module_handle_dummy);
 215         LOAD_OPT_MONO_FUNCTION(mono_trace_set_print_handler, set_print_handler_dummy);
 216         LOAD_OPT_MONO_FUNCTION(mono_trace_set_printerr_handler, set_print_handler_dummy);
 217
 218 #undef LOAD_OPT_MONO_FUNCTION
 219
 220         mono_profiler_install(NULL, mono_shutdown_callback_fn);
 221
 222         mono_trace_set_print_handler(mono_print_handler_fn);
 223         mono_trace_set_printerr_handler(mono_print_handler_fn);
 224
 225         mono_set_dirs(mono_lib_path_a, mono_etc_path_a);
 226
 227         mono_config_parse(NULL);
 228
 229         mono_install_assembly_preload_hook(mono_assembly_preload_hook_fn, NULL);
 230
 231         trace_size = GetEnvironmentVariableA("WINE_MONO_TRACE", trace_setting, sizeof(trace_setting));
 232
 233         if (trace_size)
 234         {
 235             mono_jit_set_trace_options(trace_setting);
 236         }
 237
 238         verbose_size = GetEnvironmentVariableA("WINE_MONO_VERBOSE", verbose_setting, sizeof(verbose_setting));
 239
 240         if (verbose_size)
 241         {
 242             mono_set_verbose_level(verbose_setting[0] - '0');
 243         }
 244     }
 245
 246     return S_OK;
 247
 248 fail:
 249     ERR("Could not load Mono into this process\n");
 250     FreeLibrary(mono_handle);
 251     mono_handle = NULL;
 252     return E_FAIL;
 253 }
 254
 255 static void mono_shutdown_callback_fn(MonoProfiler *prof)
 256 {
 257     is_mono_shutdown = TRUE;
 258 }
 259
 260 static void mono_print_handler_fn(const char *string, INT is_stdout)
 261 {
 262     wine_dbg_printf("%s", string);
 263 }
 264
 265 static HRESULT CLRRuntimeInfo_GetRuntimeHost(CLRRuntimeInfo *This, RuntimeHost **result)
 266 {
 267     HRESULT hr = S_OK;
 268     WCHAR mono_path[MAX_PATH];
 269
 270     if (This->loaded_runtime)
 271     {
 272         *result = This->loaded_runtime;
 273         return hr;
 274     }
 275
 276     if (!get_mono_path(mono_path))
 277     {
 278         missing_runtime_message();
 279         return CLR_E_SHIM_RUNTIME;
 280     }
 281
 282     EnterCriticalSection(&runtime_list_cs);
 283
 284     hr = load_mono(mono_path);
 285
 286     if (SUCCEEDED(hr))
 287         hr = RuntimeHost_Construct(This, &This->loaded_runtime);
 288
 289     LeaveCriticalSection(&runtime_list_cs);
 290
 291     if (SUCCEEDED(hr))
 292         *result = This->loaded_runtime;
 293
 294     return hr;
 295 }
 296
 297 void expect_no_runtimes(void)
 298 {
 299     if (mono_handle && is_mono_started && !is_mono_shutdown)
 300     {
 301         ERR("Process exited with a Mono runtime loaded.\n");
 302         return;
 303     }
 304 }
 305
 306 static inline CLRRuntimeInfo *impl_from_ICLRRuntimeInfo(ICLRRuntimeInfo *iface)
 307 {
 308     return CONTAINING_RECORD(iface, CLRRuntimeInfo, ICLRRuntimeInfo_iface);
 309 }
 310
 311 static HRESULT WINAPI CLRRuntimeInfo_QueryInterface(ICLRRuntimeInfo* iface,
 312         REFIID riid,
 313         void **ppvObject)
 314 {
 315     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 316
 317     if ( IsEqualGUID( riid, &IID_ICLRRuntimeInfo ) ||
 318          IsEqualGUID( riid, &IID_IUnknown ) )
 319     {
 320         *ppvObject = iface;
 321     }
 322     else
 323     {
 324         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 325         return E_NOINTERFACE;
 326     }
 327
 328     ICLRRuntimeInfo_AddRef( iface );
 329
 330     return S_OK;
 331 }
 332
 333 static ULONG WINAPI CLRRuntimeInfo_AddRef(ICLRRuntimeInfo* iface)
 334 {
 335     return 2;
 336 }
 337
 338 static ULONG WINAPI CLRRuntimeInfo_Release(ICLRRuntimeInfo* iface)
 339 {
 340     return 1;
 341 }
 342
 343 static HRESULT WINAPI CLRRuntimeInfo_GetVersionString(ICLRRuntimeInfo* iface,
 344     LPWSTR pwzBuffer, DWORD *pcchBuffer)
 345 {
 346     struct CLRRuntimeInfo *This = impl_from_ICLRRuntimeInfo(iface);
 347     DWORD buffer_size = *pcchBuffer;
 348     HRESULT hr = S_OK;
 349     char version[11];
 350     DWORD size;
 351
 352     TRACE("%p %p %p\n", iface, pwzBuffer, pcchBuffer);
 353
 354     size = snprintf(version, sizeof(version), "v%u.%u.%u", This->major, This->minor, This->build);
 355
 356     assert(size <= sizeof(version));
 357
 358     *pcchBuffer = MultiByteToWideChar(CP_UTF8, 0, version, -1, NULL, 0);
 359
 360     if (pwzBuffer)
 361     {
 362         if (buffer_size >= *pcchBuffer)
 363             MultiByteToWideChar(CP_UTF8, 0, version, -1, pwzBuffer, buffer_size);
 364         else
 365             hr = E_NOT_SUFFICIENT_BUFFER;
 366     }
 367
 368     return hr;
 369 }
 370
 371 static BOOL get_install_root(LPWSTR install_dir)
 372 {
 373     const WCHAR dotnet_key[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\','.','N','E','T','F','r','a','m','e','w','o','r','k','\\',0};
 374     const WCHAR install_root[] = {'I','n','s','t','a','l','l','R','o','o','t',0};
 375
 376     DWORD len;
 377     HKEY key;
 378
 379     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, dotnet_key, 0, KEY_READ, &key))
 380         return FALSE;
 381
 382     len = MAX_PATH;
 383     if (RegQueryValueExW(key, install_root, 0, NULL, (LPBYTE)install_dir, &len))
 384     {
 385         RegCloseKey(key);
 386         return FALSE;
 387     }
 388     RegCloseKey(key);
 389
 390     return TRUE;
 391 }
 392
 393 static HRESULT WINAPI CLRRuntimeInfo_GetRuntimeDirectory(ICLRRuntimeInfo* iface,
 394     LPWSTR pwzBuffer, DWORD *pcchBuffer)
 395 {
 396     static const WCHAR slash[] = {'\\',0};
 397     DWORD buffer_size = *pcchBuffer;
 398     WCHAR system_dir[MAX_PATH];
 399     WCHAR version[MAX_PATH];
 400     DWORD version_size, size;
 401     HRESULT hr = S_OK;
 402
 403     TRACE("%p %p %p\n", iface, pwzBuffer, pcchBuffer);
 404
 405     if (!get_install_root(system_dir))
 406     {
 407         ERR("error reading registry key for installroot\n");
 408         return E_FAIL;
 409     }
 410     else
 411     {
 412         version_size = MAX_PATH;
 413         ICLRRuntimeInfo_GetVersionString(iface, version, &version_size);
 414         lstrcatW(system_dir, version);
 415         lstrcatW(system_dir, slash);
 416         size = lstrlenW(system_dir) + 1;
 417     }
 418
 419     *pcchBuffer = size;
 420
 421     if (pwzBuffer)
 422     {
 423         if (buffer_size >= size)
 424             strcpyW(pwzBuffer, system_dir);
 425         else
 426             hr = E_NOT_SUFFICIENT_BUFFER;
 427     }
 428
 429     return hr;
 430 }
 431
 432 static HRESULT WINAPI CLRRuntimeInfo_IsLoaded(ICLRRuntimeInfo* iface,
 433     HANDLE hndProcess, BOOL *pbLoaded)
 434 {
 435     FIXME("%p %p %p\n", iface, hndProcess, pbLoaded);
 436
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT WINAPI CLRRuntimeInfo_LoadErrorString(ICLRRuntimeInfo* iface,
 441     UINT iResourceID, LPWSTR pwzBuffer, DWORD *pcchBuffer, LONG iLocaleid)
 442 {
 443     FIXME("%p %u %p %p %x\n", iface, iResourceID, pwzBuffer, pcchBuffer, iLocaleid);
 444
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI CLRRuntimeInfo_LoadLibrary(ICLRRuntimeInfo* iface,
 449     LPCWSTR pwzDllName, HMODULE *phndModule)
 450 {
 451     WCHAR version[MAX_PATH];
 452     HRESULT hr;
 453     DWORD cchBuffer;
 454
 455     TRACE("%p %s %p\n", iface, debugstr_w(pwzDllName), phndModule);
 456
 457     cchBuffer = MAX_PATH;
 458     hr = ICLRRuntimeInfo_GetVersionString(iface, version, &cchBuffer);
 459     if (FAILED(hr)) return hr;
 460
 461     return LoadLibraryShim(pwzDllName, version, NULL, phndModule);
 462 }
 463
 464 static HRESULT WINAPI CLRRuntimeInfo_GetProcAddress(ICLRRuntimeInfo* iface,
 465     LPCSTR pszProcName, LPVOID *ppProc)
 466 {
 467     FIXME("%p %s %p\n", iface, debugstr_a(pszProcName), ppProc);
 468
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI CLRRuntimeInfo_GetInterface(ICLRRuntimeInfo* iface,
 473     REFCLSID rclsid, REFIID riid, LPVOID *ppUnk)
 474 {
 475     struct CLRRuntimeInfo *This = impl_from_ICLRRuntimeInfo(iface);
 476     RuntimeHost *host;
 477     HRESULT hr;
 478
 479     TRACE("%p %s %s %p\n", iface, debugstr_guid(rclsid), debugstr_guid(riid), ppUnk);
 480
 481     hr = CLRRuntimeInfo_GetRuntimeHost(This, &host);
 482
 483     if (SUCCEEDED(hr))
 484         hr = RuntimeHost_GetInterface(host, rclsid, riid, ppUnk);
 485
 486     return hr;
 487 }
 488
 489 static HRESULT WINAPI CLRRuntimeInfo_IsLoadable(ICLRRuntimeInfo* iface,
 490     BOOL *pbLoadable)
 491 {
 492     FIXME("%p %p\n", iface, pbLoadable);
 493
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI CLRRuntimeInfo_SetDefaultStartupFlags(ICLRRuntimeInfo* iface,
 498     DWORD dwStartupFlags, LPCWSTR pwzHostConfigFile)
 499 {
 500     FIXME("%p %x %s\n", iface, dwStartupFlags, debugstr_w(pwzHostConfigFile));
 501
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI CLRRuntimeInfo_GetDefaultStartupFlags(ICLRRuntimeInfo* iface,
 506     DWORD *pdwStartupFlags, LPWSTR pwzHostConfigFile, DWORD *pcchHostConfigFile)
 507 {
 508     FIXME("%p %p %p %p\n", iface, pdwStartupFlags, pwzHostConfigFile, pcchHostConfigFile);
 509
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT WINAPI CLRRuntimeInfo_BindAsLegacyV2Runtime(ICLRRuntimeInfo* iface)
 514 {
 515     FIXME("%p\n", iface);
 516
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI CLRRuntimeInfo_IsStarted(ICLRRuntimeInfo* iface,
 521     BOOL *pbStarted, DWORD *pdwStartupFlags)
 522 {
 523     FIXME("%p %p %p\n", iface, pbStarted, pdwStartupFlags);
 524
 525     return E_NOTIMPL;
 526 }
 527
 528 static const struct ICLRRuntimeInfoVtbl CLRRuntimeInfoVtbl = {
 529     CLRRuntimeInfo_QueryInterface,
 530     CLRRuntimeInfo_AddRef,
 531     CLRRuntimeInfo_Release,
 532     CLRRuntimeInfo_GetVersionString,
 533     CLRRuntimeInfo_GetRuntimeDirectory,
 534     CLRRuntimeInfo_IsLoaded,
 535     CLRRuntimeInfo_LoadErrorString,
 536     CLRRuntimeInfo_LoadLibrary,
 537     CLRRuntimeInfo_GetProcAddress,
 538     CLRRuntimeInfo_GetInterface,
 539     CLRRuntimeInfo_IsLoadable,
 540     CLRRuntimeInfo_SetDefaultStartupFlags,
 541     CLRRuntimeInfo_GetDefaultStartupFlags,
 542     CLRRuntimeInfo_BindAsLegacyV2Runtime,
 543     CLRRuntimeInfo_IsStarted
 544 };
 545
 546 HRESULT ICLRRuntimeInfo_GetRuntimeHost(ICLRRuntimeInfo *iface, RuntimeHost **result)
 547 {
 548     struct CLRRuntimeInfo *This = impl_from_ICLRRuntimeInfo(iface);
 549
 550     assert(This->ICLRRuntimeInfo_iface.lpVtbl == &CLRRuntimeInfoVtbl);
 551
 552     return CLRRuntimeInfo_GetRuntimeHost(This, result);
 553 }
 554
 555 #ifdef __i386__
 556 static const WCHAR libmono2_arch_dll[] = {'\\','b','i','n','\\','l','i','b','m','o','n','o','-','2','.','0','-','x','8','6','.','d','l','l',0};
 557 #elif defined(__x86_64__)
 558 static const WCHAR libmono2_arch_dll[] = {'\\','b','i','n','\\','l','i','b','m','o','n','o','-','2','.','0','-','x','8','6','_','6','4','.','d','l','l',0};
 559 #else
 560 static const WCHAR libmono2_arch_dll[] = {'\\','b','i','n','\\','l','i','b','m','o','n','o','-','2','.','0','.','d','l','l',0};
 561 #endif
 562
 563 static BOOL find_mono_dll(LPCWSTR path, LPWSTR dll_path)
 564 {
 565     static const WCHAR mono2_dll[] = {'\\','b','i','n','\\','m','o','n','o','-','2','.','0','.','d','l','l',0};
 566     static const WCHAR libmono2_dll[] = {'\\','b','i','n','\\','l','i','b','m','o','n','o','-','2','.','0','.','d','l','l',0};
 567     DWORD attributes=INVALID_FILE_ATTRIBUTES;
 568
 569     strcpyW(dll_path, path);
 570     strcatW(dll_path, libmono2_arch_dll);
 571     attributes = GetFileAttributesW(dll_path);
 572
 573     if (attributes == INVALID_FILE_ATTRIBUTES)
 574     {
 575         strcpyW(dll_path, path);
 576         strcatW(dll_path, mono2_dll);
 577         attributes = GetFileAttributesW(dll_path);
 578     }
 579
 580     if (attributes == INVALID_FILE_ATTRIBUTES)
 581     {
 582         strcpyW(dll_path, path);
 583         strcatW(dll_path, libmono2_dll);
 584         attributes = GetFileAttributesW(dll_path);
 585     }
 586
 587     return (attributes != INVALID_FILE_ATTRIBUTES);
 588 }
 589
 590 static BOOL get_mono_path_from_registry(LPWSTR path)
 591 {
 592     static const WCHAR mono_key[] = {'S','o','f','t','w','a','r','e','\\','N','o','v','e','l','l','\\','M','o','n','o',0};
 593     static const WCHAR defaul_clr[] = {'D','e','f','a','u','l','t','C','L','R',0};
 594     static const WCHAR install_root[] = {'S','d','k','I','n','s','t','a','l','l','R','o','o','t',0};
 595     static const WCHAR slash[] = {'\\',0};
 596
 597     WCHAR version[64], version_key[MAX_PATH];
 598     DWORD len;
 599     HKEY key;
 600     WCHAR dll_path[MAX_PATH];
 601
 602     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, mono_key, 0, KEY_READ, &key))
 603         return FALSE;
 604
 605     len = sizeof(version);
 606     if (RegQueryValueExW(key, defaul_clr, 0, NULL, (LPBYTE)version, &len))
 607     {
 608         RegCloseKey(key);
 609         return FALSE;
 610     }
 611     RegCloseKey(key);
 612
 613     lstrcpyW(version_key, mono_key);
 614     lstrcatW(version_key, slash);
 615     lstrcatW(version_key, version);
 616
 617     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, version_key, 0, KEY_READ, &key))
 618         return FALSE;
 619
 620     len = sizeof(WCHAR) * MAX_PATH;
 621     if (RegQueryValueExW(key, install_root, 0, NULL, (LPBYTE)path, &len))
 622     {
 623         RegCloseKey(key);
 624         return FALSE;
 625     }
 626     RegCloseKey(key);
 627
 628     return find_mono_dll(path, dll_path);
 629 }
 630
 631 static BOOL get_mono_path_from_folder(LPCWSTR folder, LPWSTR mono_path)
 632 {
 633     static const WCHAR mono_two_dot_zero[] = {'\\','m','o','n','o','-','2','.','0', 0};
 634     WCHAR mono_dll_path[MAX_PATH];
 635     BOOL found = FALSE;
 636
 637     strcpyW(mono_path, folder);
 638
 639     strcatW(mono_path, mono_two_dot_zero);
 640
 641     found = find_mono_dll(mono_path, mono_dll_path);
 642
 643     return found;
 644 }
 645
 646 static BOOL get_mono_path(LPWSTR path)
 647 {
 648     static const WCHAR subdir_mono[] = {'\\','m','o','n','o',0};
 649     static const WCHAR sibling_mono[] = {'\\','.','.','\\','m','o','n','o',0};
 650     WCHAR base_path[MAX_PATH];
 651     const char *unix_data_dir;
 652     WCHAR *dos_data_dir;
 653     BOOL build_tree = FALSE;
 654     static WCHAR* (CDECL *wine_get_dos_file_name)(const char*);
 655
 656     /* First try c:\windows\mono */
 657     GetWindowsDirectoryW(base_path, MAX_PATH);
 658     strcatW(base_path, subdir_mono);
 659
 660     if (get_mono_path_from_folder(base_path, path))
 661         return TRUE;
 662
 663     /* Next: /usr/share/wine/mono */
 664     unix_data_dir = wine_get_data_dir();
 665
 666     if (!unix_data_dir)
 667     {
 668         unix_data_dir = wine_get_build_dir();
 669         build_tree = TRUE;
 670     }
 671
 672     if (unix_data_dir)
 673     {
 674         if (!wine_get_dos_file_name)
 675             wine_get_dos_file_name = (void*)GetProcAddress(GetModuleHandleA("kernel32"), "wine_get_dos_file_name");
 676
 677         if (wine_get_dos_file_name)
 678         {
 679             dos_data_dir = wine_get_dos_file_name(unix_data_dir);
 680
 681             if (dos_data_dir)
 682             {
 683                 strcpyW(base_path, dos_data_dir);
 684                 strcatW(base_path, build_tree ? sibling_mono : subdir_mono);
 685
 686                 HeapFree(GetProcessHeap(), 0, dos_data_dir);
 687
 688                 if (get_mono_path_from_folder(base_path, path))
 689                     return TRUE;
 690             }
 691         }
 692     }
 693
 694     /* Last: the registry */
 695     return get_mono_path_from_registry(path);
 696 }
 697
 698 struct InstalledRuntimeEnum
 699 {
 700     IEnumUnknown IEnumUnknown_iface;
 701     LONG ref;
 702     ULONG pos;
 703 };
 704
 705 static const struct IEnumUnknownVtbl InstalledRuntimeEnum_Vtbl;
 706
 707 static inline struct InstalledRuntimeEnum *impl_from_IEnumUnknown(IEnumUnknown *iface)
 708 {
 709     return CONTAINING_RECORD(iface, struct InstalledRuntimeEnum, IEnumUnknown_iface);
 710 }
 711
 712 static HRESULT WINAPI InstalledRuntimeEnum_QueryInterface(IEnumUnknown* iface, REFIID riid,
 713         void **ppvObject)
 714 {
 715     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 716
 717     if ( IsEqualGUID( riid, &IID_IEnumUnknown ) ||
 718          IsEqualGUID( riid, &IID_IUnknown ) )
 719     {
 720         *ppvObject = iface;
 721     }
 722     else
 723     {
 724         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 725         return E_NOINTERFACE;
 726     }
 727
 728     IEnumUnknown_AddRef( iface );
 729
 730     return S_OK;
 731 }
 732
 733 static ULONG WINAPI InstalledRuntimeEnum_AddRef(IEnumUnknown* iface)
 734 {
 735     struct InstalledRuntimeEnum *This = impl_from_IEnumUnknown(iface);
 736     ULONG ref = InterlockedIncrement(&This->ref);
 737
 738     TRACE("(%p) refcount=%u\n", iface, ref);
 739
 740     return ref;
 741 }
 742
 743 static ULONG WINAPI InstalledRuntimeEnum_Release(IEnumUnknown* iface)
 744 {
 745     struct InstalledRuntimeEnum *This = impl_from_IEnumUnknown(iface);
 746     ULONG ref = InterlockedDecrement(&This->ref);
 747
 748     TRACE("(%p) refcount=%u\n", iface, ref);
 749
 750     if (ref == 0)
 751     {
 752         HeapFree(GetProcessHeap(), 0, This);
 753     }
 754
 755     return ref;
 756 }
 757
 758 static HRESULT WINAPI InstalledRuntimeEnum_Next(IEnumUnknown *iface, ULONG celt,
 759     IUnknown **rgelt, ULONG *pceltFetched)
 760 {
 761     struct InstalledRuntimeEnum *This = impl_from_IEnumUnknown(iface);
 762     ULONG num_fetched = 0;
 763     HRESULT hr=S_OK;
 764     IUnknown *item;
 765
 766     TRACE("(%p,%u,%p,%p)\n", iface, celt, rgelt, pceltFetched);
 767
 768     while (num_fetched < celt)
 769     {
 770         if (This->pos >= NUM_RUNTIMES)
 771         {
 772             hr = S_FALSE;
 773             break;
 774         }
 775         item = (IUnknown*)&runtimes[This->pos].ICLRRuntimeInfo_iface;
 776         IUnknown_AddRef(item);
 777         rgelt[num_fetched] = item;
 778         num_fetched++;
 779         This->pos++;
 780     }
 781
 782     if (pceltFetched)
 783         *pceltFetched = num_fetched;
 784
 785     return hr;
 786 }
 787
 788 static HRESULT WINAPI InstalledRuntimeEnum_Skip(IEnumUnknown *iface, ULONG celt)
 789 {
 790     struct InstalledRuntimeEnum *This = impl_from_IEnumUnknown(iface);
 791     ULONG num_fetched = 0;
 792     HRESULT hr=S_OK;
 793
 794     TRACE("(%p,%u)\n", iface, celt);
 795
 796     while (num_fetched < celt)
 797     {
 798         if (This->pos >= NUM_RUNTIMES)
 799         {
 800             hr = S_FALSE;
 801             break;
 802         }
 803         num_fetched++;
 804         This->pos++;
 805     }
 806
 807     return hr;
 808 }
 809
 810 static HRESULT WINAPI InstalledRuntimeEnum_Reset(IEnumUnknown *iface)
 811 {
 812     struct InstalledRuntimeEnum *This = impl_from_IEnumUnknown(iface);
 813
 814     TRACE("(%p)\n", iface);
 815
 816     This->pos = 0;
 817
 818     return S_OK;
 819 }
 820
 821 static HRESULT WINAPI InstalledRuntimeEnum_Clone(IEnumUnknown *iface, IEnumUnknown **ppenum)
 822 {
 823     struct InstalledRuntimeEnum *This = impl_from_IEnumUnknown(iface);
 824     struct InstalledRuntimeEnum *new_enum;
 825
 826     TRACE("(%p)\n", iface);
 827
 828     new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_enum));
 829     if (!new_enum)
 830         return E_OUTOFMEMORY;
 831
 832     new_enum->IEnumUnknown_iface.lpVtbl = &InstalledRuntimeEnum_Vtbl;
 833     new_enum->ref = 1;
 834     new_enum->pos = This->pos;
 835
 836     *ppenum = &new_enum->IEnumUnknown_iface;
 837
 838     return S_OK;
 839 }
 840
 841 static const struct IEnumUnknownVtbl InstalledRuntimeEnum_Vtbl = {
 842     InstalledRuntimeEnum_QueryInterface,
 843     InstalledRuntimeEnum_AddRef,
 844     InstalledRuntimeEnum_Release,
 845     InstalledRuntimeEnum_Next,
 846     InstalledRuntimeEnum_Skip,
 847     InstalledRuntimeEnum_Reset,
 848     InstalledRuntimeEnum_Clone
 849 };
 850
 851 struct CLRMetaHost
 852 {
 853     ICLRMetaHost ICLRMetaHost_iface;
 854
 855     RuntimeLoadedCallbackFnPtr callback;
 856 };
 857
 858 static struct CLRMetaHost GlobalCLRMetaHost;
 859
 860 static HRESULT WINAPI CLRMetaHost_QueryInterface(ICLRMetaHost* iface,
 861         REFIID riid,
 862         void **ppvObject)
 863 {
 864     TRACE("%s %p\n", debugstr_guid(riid), ppvObject);
 865
 866     if ( IsEqualGUID( riid, &IID_ICLRMetaHost ) ||
 867          IsEqualGUID( riid, &IID_IUnknown ) )
 868     {
 869         *ppvObject = iface;
 870     }
 871     else
 872     {
 873         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 874         return E_NOINTERFACE;
 875     }
 876
 877     ICLRMetaHost_AddRef( iface );
 878
 879     return S_OK;
 880 }
 881
 882 static ULONG WINAPI CLRMetaHost_AddRef(ICLRMetaHost* iface)
 883 {
 884     return 2;
 885 }
 886
 887 static ULONG WINAPI CLRMetaHost_Release(ICLRMetaHost* iface)
 888 {
 889     return 1;
 890 }
 891
 892 static BOOL parse_runtime_version(LPCWSTR version, DWORD *major, DWORD *minor, DWORD *build)
 893 {
 894     *major = 0;
 895     *minor = 0;
 896     *build = 0;
 897
 898     if (version[0] == 'v' || version[0] == 'V')
 899     {
 900         version++;
 901         if (!isdigit(*version))
 902             return FALSE;
 903
 904         while (isdigit(*version))
 905             *major = *major * 10 + (*version++ - '0');
 906
 907         if (*version == 0)
 908             return TRUE;
 909
 910         if (*version++ != '.' || !isdigit(*version))
 911             return FALSE;
 912
 913         while (isdigit(*version))
 914             *minor = *minor * 10 + (*version++ - '0');
 915
 916         if (*version == 0)
 917             return TRUE;
 918
 919         if (*version++ != '.' || !isdigit(*version))
 920             return FALSE;
 921
 922         while (isdigit(*version))
 923             *build = *build * 10 + (*version++ - '0');
 924
 925         return *version == 0;
 926     }
 927     else
 928         return FALSE;
 929 }
 930
 931 static HRESULT get_runtime(LPCWSTR pwzVersion, BOOL allow_short,
 932     REFIID iid, LPVOID *ppRuntime)
 933 {
 934     int i;
 935     DWORD major, minor, build;
 936
 937     if (!pwzVersion)
 938         return E_POINTER;
 939
 940     if (!parse_runtime_version(pwzVersion, &major, &minor, &build))
 941     {
 942         ERR("Cannot parse %s\n", debugstr_w(pwzVersion));
 943         return CLR_E_SHIM_RUNTIME;
 944     }
 945
 946     for (i=0; i<NUM_RUNTIMES; i++)
 947     {
 948         if (runtimes[i].major == major && runtimes[i].minor == minor &&
 949             (runtimes[i].build == build || (allow_short && major >= 4 && build == 0)))
 950         {
 951             return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface, iid,
 952                     ppRuntime);
 953         }
 954     }
 955
 956     FIXME("Unrecognized version %s\n", debugstr_w(pwzVersion));
 957     return CLR_E_SHIM_RUNTIME;
 958 }
 959
 960 HRESULT WINAPI CLRMetaHost_GetRuntime(ICLRMetaHost* iface,
 961     LPCWSTR pwzVersion, REFIID iid, LPVOID *ppRuntime)
 962 {
 963     TRACE("%s %s %p\n", debugstr_w(pwzVersion), debugstr_guid(iid), ppRuntime);
 964
 965     return get_runtime(pwzVersion, FALSE, iid, ppRuntime);
 966 }
 967
 968 HRESULT WINAPI CLRMetaHost_GetVersionFromFile(ICLRMetaHost* iface,
 969     LPCWSTR pwzFilePath, LPWSTR pwzBuffer, DWORD *pcchBuffer)
 970 {
 971     ASSEMBLY *assembly;
 972     HRESULT hr;
 973     LPSTR version;
 974     ULONG buffer_size=*pcchBuffer;
 975
 976     TRACE("%s %p %p\n", debugstr_w(pwzFilePath), pwzBuffer, pcchBuffer);
 977
 978     hr = assembly_create(&assembly, pwzFilePath);
 979
 980     if (SUCCEEDED(hr))
 981     {
 982         hr = assembly_get_runtime_version(assembly, &version);
 983
 984         if (SUCCEEDED(hr))
 985         {
 986             *pcchBuffer = MultiByteToWideChar(CP_UTF8, 0, version, -1, NULL, 0);
 987
 988             if (pwzBuffer)
 989             {
 990                 if (buffer_size >= *pcchBuffer)
 991                     MultiByteToWideChar(CP_UTF8, 0, version, -1, pwzBuffer, buffer_size);
 992                 else
 993                     hr = E_NOT_SUFFICIENT_BUFFER;
 994             }
 995         }
 996
 997         assembly_release(assembly);
 998     }
 999
1000     return hr;
1001 }
1002
1003 static HRESULT WINAPI CLRMetaHost_EnumerateInstalledRuntimes(ICLRMetaHost* iface,
1004     IEnumUnknown **ppEnumerator)
1005 {
1006     struct InstalledRuntimeEnum *new_enum;
1007
1008     TRACE("%p\n", ppEnumerator);
1009
1010     new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_enum));
1011     if (!new_enum)
1012         return E_OUTOFMEMORY;
1013
1014     new_enum->IEnumUnknown_iface.lpVtbl = &InstalledRuntimeEnum_Vtbl;
1015     new_enum->ref = 1;
1016     new_enum->pos = 0;
1017
1018     *ppEnumerator = &new_enum->IEnumUnknown_iface;
1019
1020     return S_OK;
1021 }
1022
1023 static HRESULT WINAPI CLRMetaHost_EnumerateLoadedRuntimes(ICLRMetaHost* iface,
1024     HANDLE hndProcess, IEnumUnknown **ppEnumerator)
1025 {
1026     FIXME("%p %p\n", hndProcess, ppEnumerator);
1027
1028     return E_NOTIMPL;
1029 }
1030
1031 static HRESULT WINAPI CLRMetaHost_RequestRuntimeLoadedNotification(ICLRMetaHost* iface,
1032     RuntimeLoadedCallbackFnPtr pCallbackFunction)
1033 {
1034     TRACE("%p\n", pCallbackFunction);
1035
1036     if(!pCallbackFunction)
1037         return E_POINTER;
1038
1039     WARN("Callback currently will not be called.\n");
1040
1041     GlobalCLRMetaHost.callback = pCallbackFunction;
1042
1043     return S_OK;
1044 }
1045
1046 static HRESULT WINAPI CLRMetaHost_QueryLegacyV2RuntimeBinding(ICLRMetaHost* iface,
1047     REFIID riid, LPVOID *ppUnk)
1048 {
1049     FIXME("%s %p\n", debugstr_guid(riid), ppUnk);
1050
1051     return E_NOTIMPL;
1052 }
1053
1054 HRESULT WINAPI CLRMetaHost_ExitProcess(ICLRMetaHost* iface, INT32 iExitCode)
1055 {
1056     TRACE("%i\n", iExitCode);
1057
1058     EnterCriticalSection(&runtime_list_cs);
1059
1060     if (is_mono_started && !is_mono_shutdown)
1061     {
1062         /* search for a runtime and call System.Environment.Exit() */
1063         int i;
1064
1065         for (i=0; i<NUM_RUNTIMES; i++)
1066             if (runtimes[i].loaded_runtime)
1067                 RuntimeHost_ExitProcess(runtimes[i].loaded_runtime, iExitCode);
1068     }
1069
1070     ExitProcess(iExitCode);
1071 }
1072
1073 static const struct ICLRMetaHostVtbl CLRMetaHost_vtbl =
1074 {
1075     CLRMetaHost_QueryInterface,
1076     CLRMetaHost_AddRef,
1077     CLRMetaHost_Release,
1078     CLRMetaHost_GetRuntime,
1079     CLRMetaHost_GetVersionFromFile,
1080     CLRMetaHost_EnumerateInstalledRuntimes,
1081     CLRMetaHost_EnumerateLoadedRuntimes,
1082     CLRMetaHost_RequestRuntimeLoadedNotification,
1083     CLRMetaHost_QueryLegacyV2RuntimeBinding,
1084     CLRMetaHost_ExitProcess
1085 };
1086
1087 static struct CLRMetaHost GlobalCLRMetaHost = {
1088     { &CLRMetaHost_vtbl }
1089 };
1090
1091 HRESULT CLRMetaHost_CreateInstance(REFIID riid, void **ppobj)
1092 {
1093     return ICLRMetaHost_QueryInterface(&GlobalCLRMetaHost.ICLRMetaHost_iface, riid, ppobj);
1094 }
1095
1096 struct CLRMetaHostPolicy
1097 {
1098     ICLRMetaHostPolicy ICLRMetaHostPolicy_iface;
1099 };
1100
1101 static struct CLRMetaHostPolicy GlobalCLRMetaHostPolicy;
1102
1103 static HRESULT WINAPI metahostpolicy_QueryInterface(ICLRMetaHostPolicy *iface, REFIID riid, void **obj)
1104 {
1105     TRACE("%s %p\n", debugstr_guid(riid), obj);
1106
1107     if ( IsEqualGUID( riid, &IID_ICLRMetaHostPolicy ) ||
1108          IsEqualGUID( riid, &IID_IUnknown ) )
1109     {
1110         ICLRMetaHostPolicy_AddRef( iface );
1111         *obj = iface;
1112         return S_OK;
1113     }
1114
1115     FIXME("Unsupported interface %s\n", debugstr_guid(riid));
1116
1117     *obj = NULL;
1118     return E_NOINTERFACE;
1119 }
1120
1121 static ULONG WINAPI metahostpolicy_AddRef(ICLRMetaHostPolicy *iface)
1122 {
1123     return 2;
1124 }
1125
1126 static ULONG WINAPI metahostpolicy_Release(ICLRMetaHostPolicy *iface)
1127 {
1128     return 1;
1129 }
1130
1131 static HRESULT WINAPI metahostpolicy_GetRequestedRuntime(ICLRMetaHostPolicy *iface, METAHOST_POLICY_FLAGS dwPolicyFlags,
1132     LPCWSTR pwzBinary, IStream *pCfgStream, LPWSTR pwzVersion, DWORD *pcchVersion,
1133     LPWSTR pwzImageVersion, DWORD *pcchImageVersion, DWORD *pdwConfigFlags, REFIID riid,
1134     LPVOID *ppRuntime)
1135 {
1136     ICLRRuntimeInfo *result;
1137     HRESULT hr;
1138     WCHAR filename[MAX_PATH];
1139     const WCHAR *path = NULL;
1140     int flags = 0;
1141
1142     TRACE("%d %p %p %p %p %p %p %p %s %p\n", dwPolicyFlags, pwzBinary, pCfgStream,
1143         pwzVersion, pcchVersion, pwzImageVersion, pcchImageVersion, pdwConfigFlags,
1144         debugstr_guid(riid), ppRuntime);
1145
1146     if (pCfgStream)
1147         FIXME("ignoring config file stream\n");
1148
1149     if (pdwConfigFlags)
1150         FIXME("ignoring config flags\n");
1151
1152     if(dwPolicyFlags & METAHOST_POLICY_USE_PROCESS_IMAGE_PATH)
1153     {
1154         GetModuleFileNameW(0, filename, MAX_PATH);
1155         path = filename;
1156     }
1157     else if(pwzBinary)
1158     {
1159         path = pwzBinary;
1160     }
1161
1162     if(dwPolicyFlags & METAHOST_POLICY_APPLY_UPGRADE_POLICY)
1163         flags |= RUNTIME_INFO_UPGRADE_VERSION;
1164
1165     hr = get_runtime_info(path, pwzImageVersion, NULL, 0, flags, FALSE, &result);
1166     if (SUCCEEDED(hr))
1167     {
1168         if (pwzImageVersion)
1169         {
1170             /* Ignoring errors on purpose */
1171             ICLRRuntimeInfo_GetVersionString(result, pwzImageVersion, pcchImageVersion);
1172         }
1173
1174         hr = ICLRRuntimeInfo_QueryInterface(result, riid, ppRuntime);
1175
1176         ICLRRuntimeInfo_Release(result);
1177     }
1178
1179     TRACE("<- 0x%08x\n", hr);
1180
1181     return hr;
1182 }
1183
1184 static const struct ICLRMetaHostPolicyVtbl CLRMetaHostPolicy_vtbl =
1185 {
1186     metahostpolicy_QueryInterface,
1187     metahostpolicy_AddRef,
1188     metahostpolicy_Release,
1189     metahostpolicy_GetRequestedRuntime
1190 };
1191
1192 static struct CLRMetaHostPolicy GlobalCLRMetaHostPolicy = {
1193     { &CLRMetaHostPolicy_vtbl }
1194 };
1195
1196 HRESULT CLRMetaHostPolicy_CreateInstance(REFIID riid, void **ppobj)
1197 {
1198     return ICLRMetaHostPolicy_QueryInterface(&GlobalCLRMetaHostPolicy.ICLRMetaHostPolicy_iface, riid, ppobj);
1199 }
1200
1201 HRESULT get_file_from_strongname(WCHAR* stringnameW, WCHAR* assemblies_path, int path_length)
1202 {
1203     HRESULT hr=S_OK;
1204     IAssemblyCache *asmcache;
1205     ASSEMBLY_INFO info;
1206     static const WCHAR fusiondll[] = {'f','u','s','i','o','n',0};
1207     HMODULE hfusion=NULL;
1208     static HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache**,DWORD);
1209
1210     if (!pCreateAssemblyCache)
1211     {
1212         hr = LoadLibraryShim(fusiondll, NULL, NULL, &hfusion);
1213
1214         if (SUCCEEDED(hr))
1215         {
1216             pCreateAssemblyCache = (void*)GetProcAddress(hfusion, "CreateAssemblyCache");
1217             if (!pCreateAssemblyCache)
1218                 hr = E_FAIL;
1219         }
1220     }
1221
1222     if (SUCCEEDED(hr))
1223         hr = pCreateAssemblyCache(&asmcache, 0);
1224
1225     if (SUCCEEDED(hr))
1226     {
1227         info.cbAssemblyInfo = sizeof(info);
1228         info.pszCurrentAssemblyPathBuf = assemblies_path;
1229         info.cchBuf = path_length;
1230         assemblies_path[0] = 0;
1231
1232         hr = IAssemblyCache_QueryAssemblyInfo(asmcache, 0, stringnameW, &info);
1233
1234         IAssemblyCache_Release(asmcache);
1235     }
1236
1237     return hr;
1238 }
1239
1240 static MonoAssembly* mono_assembly_preload_hook_fn(MonoAssemblyName *aname, char **assemblies_path, void *user_data)
1241 {
1242     HRESULT hr;
1243     MonoAssembly *result=NULL;
1244     char *stringname=NULL;
1245     LPWSTR stringnameW;
1246     int stringnameW_size;
1247     WCHAR path[MAX_PATH];
1248     char *pathA;
1249     MonoImageOpenStatus stat;
1250
1251     stringname = mono_stringify_assembly_name(aname);
1252
1253     TRACE("%s\n", debugstr_a(stringname));
1254
1255     if (!stringname) return NULL;
1256
1257     /* FIXME: We should search the given paths before the GAC. */
1258
1259     stringnameW_size = MultiByteToWideChar(CP_UTF8, 0, stringname, -1, NULL, 0);
1260
1261     stringnameW = HeapAlloc(GetProcessHeap(), 0, stringnameW_size * sizeof(WCHAR));
1262     if (stringnameW)
1263     {
1264         MultiByteToWideChar(CP_UTF8, 0, stringname, -1, stringnameW, stringnameW_size);
1265
1266         hr = get_file_from_strongname(stringnameW, path, MAX_PATH);
1267
1268         HeapFree(GetProcessHeap(), 0, stringnameW);
1269     }
1270     else
1271         hr = E_OUTOFMEMORY;
1272
1273     if (SUCCEEDED(hr))
1274     {
1275         TRACE("found: %s\n", debugstr_w(path));
1276
1277         pathA = WtoA(path);
1278
1279         if (pathA)
1280         {
1281             result = mono_assembly_open(pathA, &stat);
1282
1283             if (!result)
1284                 ERR("Failed to load %s, status=%u\n", debugstr_w(path), stat);
1285
1286             HeapFree(GetProcessHeap(), 0, pathA);
1287         }
1288     }
1289
1290     mono_free(stringname);
1291
1292     return result;
1293 }
1294
1295 HRESULT get_runtime_info(LPCWSTR exefile, LPCWSTR version, LPCWSTR config_file,
1296     DWORD startup_flags, DWORD runtimeinfo_flags, BOOL legacy, ICLRRuntimeInfo **result)
1297 {
1298     static const WCHAR dotconfig[] = {'.','c','o','n','f','i','g',0};
1299     static const DWORD supported_startup_flags = 0;
1300     static const DWORD supported_runtime_flags = RUNTIME_INFO_UPGRADE_VERSION;
1301     int i;
1302     WCHAR local_version[MAX_PATH];
1303     ULONG local_version_size = MAX_PATH;
1304     WCHAR local_config_file[MAX_PATH];
1305     HRESULT hr;
1306     parsed_config_file parsed_config;
1307
1308     if (startup_flags & ~supported_startup_flags)
1309         FIXME("unsupported startup flags %x\n", startup_flags & ~supported_startup_flags);
1310
1311     if (runtimeinfo_flags & ~supported_runtime_flags)
1312         FIXME("unsupported runtimeinfo flags %x\n", runtimeinfo_flags & ~supported_runtime_flags);
1313
1314     if (exefile && !exefile[0])
1315         exefile = NULL;
1316
1317     if (exefile && !config_file)
1318     {
1319         strcpyW(local_config_file, exefile);
1320         strcatW(local_config_file, dotconfig);
1321
1322         config_file = local_config_file;
1323     }
1324
1325     if (config_file)
1326     {
1327         BOOL found = FALSE;
1328         hr = parse_config_file(config_file, &parsed_config);
1329
1330         if (SUCCEEDED(hr))
1331         {
1332             supported_runtime *entry;
1333             LIST_FOR_EACH_ENTRY(entry, &parsed_config.supported_runtimes, supported_runtime, entry)
1334             {
1335                 hr = get_runtime(entry->version, TRUE, &IID_ICLRRuntimeInfo, (void**)result);
1336                 if (SUCCEEDED(hr))
1337                 {
1338                     found = TRUE;
1339                     break;
1340                 }
1341             }
1342         }
1343         else
1344         {
1345             WARN("failed to parse config file %s, hr=%x\n", debugstr_w(config_file), hr);
1346         }
1347
1348         free_parsed_config_file(&parsed_config);
1349
1350         if (found)
1351             return S_OK;
1352     }
1353
1354     if (exefile && !version)
1355     {
1356         hr = CLRMetaHost_GetVersionFromFile(0, exefile, local_version, &local_version_size);
1357
1358         version = local_version;
1359
1360         if (FAILED(hr)) return hr;
1361     }
1362
1363     if (version)
1364     {
1365         hr = CLRMetaHost_GetRuntime(0, version, &IID_ICLRRuntimeInfo, (void**)result);
1366         if(SUCCEEDED(hr))
1367             return hr;
1368     }
1369
1370     if (runtimeinfo_flags & RUNTIME_INFO_UPGRADE_VERSION)
1371     {
1372         DWORD major, minor, build;
1373
1374         if (version && !parse_runtime_version(version, &major, &minor, &build))
1375         {
1376             ERR("Cannot parse %s\n", debugstr_w(version));
1377             return CLR_E_SHIM_RUNTIME;
1378         }
1379
1380         if (legacy)
1381             i = 3;
1382         else
1383             i = NUM_RUNTIMES;
1384
1385         while (i--)
1386         {
1387             /* Must be greater or equal to the version passed in. */
1388             if (!version || ((runtimes[i].major >= major && runtimes[i].minor >= minor && runtimes[i].build >= build) ||
1389                  (runtimes[i].major >= major && runtimes[i].minor > minor) ||
1390                  (runtimes[i].major > major)))
1391             {
1392                 return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface,
1393                         &IID_ICLRRuntimeInfo, (void **)result);
1394             }
1395         }
1396
1397         missing_runtime_message();
1398
1399         return CLR_E_SHIM_RUNTIME;
1400     }
1401
1402     return CLR_E_SHIM_RUNTIME;
1403 }