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