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