ReactOS  0.4.14-dev-554-g2f8d847
metahost.c
Go to the documentation of this file.
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 "mscoree_private.h"
22 
23 #include <stdio.h>
24 #include <assert.h>
25 
26 #include <wine/library.h>
27 
28 #include <fusion.h>
29 
30 static const WCHAR net_11_subdir[] = {'1','.','0',0};
31 static const WCHAR net_20_subdir[] = {'2','.','0',0};
32 static const WCHAR net_40_subdir[] = {'4','.','0',0};
33 
34 static const struct ICLRRuntimeInfoVtbl CLRRuntimeInfoVtbl;
35 
36 #define NUM_RUNTIMES 3
37 
39  {{&CLRRuntimeInfoVtbl}, net_11_subdir, 1, 1, 4322, 0},
40  {{&CLRRuntimeInfoVtbl}, net_20_subdir, 2, 0, 50727, 0},
41  {{&CLRRuntimeInfoVtbl}, net_40_subdir, 4, 0, 30319, 0}
42 };
43 
45 
48 {
49  0, 0, &runtime_list_cs,
52  0, 0, { (DWORD_PTR)(__FILE__ ": runtime_list_cs") }
53 };
54 static CRITICAL_SECTION runtime_list_cs = { &runtime_list_cs_debug, -1, 0, 0, 0, 0 };
55 
56 #define NUM_ABI_VERSIONS 2
57 
59 
60 static BOOL find_mono_dll(LPCWSTR path, LPWSTR dll_path, int abi_version);
61 
62 static MonoAssembly* mono_assembly_search_hook_fn(MonoAssemblyName *aname, char **assemblies_path, void *user_data);
63 
64 static void mono_shutdown_callback_fn(MonoProfiler *prof);
65 
66 static void set_environment(LPCWSTR bin_path)
67 {
68  WCHAR path_env[MAX_PATH];
69  int len;
70 
71  static const WCHAR pathW[] = {'P','A','T','H',0};
72 
73  /* We have to modify PATH as Mono loads other DLLs from this directory. */
74  GetEnvironmentVariableW(pathW, path_env, sizeof(path_env)/sizeof(WCHAR));
75  len = strlenW(path_env);
76  path_env[len++] = ';';
77  strcpyW(path_env+len, bin_path);
78  SetEnvironmentVariableW(pathW, path_env);
79 }
80 
81 static void CDECL do_nothing(void)
82 {
83 }
84 
86 {
87  if (This->major == 1)
88  MESSAGE("wine: Install Mono 2.6 for Windows to run .NET 1.1 applications.\n");
89  else if (This->major == 2)
90  MESSAGE("wine: Install Mono for Windows to run .NET 2.0 applications.\n");
91  else if (This->major == 4)
92  MESSAGE("wine: Install Mono 2.8 or greater for Windows to run .NET 4.0 applications.\n");
93 }
94 
96 {
97  static const WCHAR bin[] = {'\\','b','i','n',0};
98  static const WCHAR lib[] = {'\\','l','i','b',0};
99  static const WCHAR etc[] = {'\\','e','t','c',0};
100  static const WCHAR glibdll[] = {'l','i','b','g','l','i','b','-','2','.','0','-','0','.','d','l','l',0};
101  WCHAR mono_dll_path[MAX_PATH+16], mono_bin_path[MAX_PATH+4];
102  WCHAR mono_lib_path[MAX_PATH+4], mono_etc_path[MAX_PATH+4];
103  char mono_lib_path_a[MAX_PATH], mono_etc_path_a[MAX_PATH];
104  int trace_size;
105  char trace_setting[256];
106 
107  if (This->mono_abi_version <= 0 || This->mono_abi_version > NUM_ABI_VERSIONS)
108  {
110  return E_FAIL;
111  }
112 
113  *result = &loaded_monos[This->mono_abi_version-1];
114 
115  if ((*result)->is_shutdown)
116  {
117  ERR("Cannot load Mono after it has been shut down.\n");
118  *result = NULL;
119  return E_FAIL;
120  }
121 
122  if (!(*result)->mono_handle)
123  {
124  strcpyW(mono_bin_path, This->mono_path);
125  strcatW(mono_bin_path, bin);
126  set_environment(mono_bin_path);
127 
128  strcpyW(mono_lib_path, This->mono_path);
129  strcatW(mono_lib_path, lib);
130  WideCharToMultiByte(CP_UTF8, 0, mono_lib_path, -1, mono_lib_path_a, MAX_PATH, NULL, NULL);
131 
132  strcpyW(mono_etc_path, This->mono_path);
133  strcatW(mono_etc_path, etc);
134  WideCharToMultiByte(CP_UTF8, 0, mono_etc_path, -1, mono_etc_path_a, MAX_PATH, NULL, NULL);
135 
136  if (!find_mono_dll(This->mono_path, mono_dll_path, This->mono_abi_version)) goto fail;
137 
138  (*result)->mono_handle = LoadLibraryW(mono_dll_path);
139 
140  if (!(*result)->mono_handle) goto fail;
141 
142 #define LOAD_MONO_FUNCTION(x) do { \
143  (*result)->x = (void*)GetProcAddress((*result)->mono_handle, #x); \
144  if (!(*result)->x) { \
145  goto fail; \
146  } \
147 } while (0);
148 
149  LOAD_MONO_FUNCTION(mono_assembly_get_image);
150  LOAD_MONO_FUNCTION(mono_assembly_load_from);
151  LOAD_MONO_FUNCTION(mono_assembly_open);
152  LOAD_MONO_FUNCTION(mono_config_parse);
153  LOAD_MONO_FUNCTION(mono_class_from_mono_type);
154  LOAD_MONO_FUNCTION(mono_class_from_name);
155  LOAD_MONO_FUNCTION(mono_class_get_method_from_name);
156  LOAD_MONO_FUNCTION(mono_domain_assembly_open);
157  LOAD_MONO_FUNCTION(mono_image_open_from_module_handle);
158  LOAD_MONO_FUNCTION(mono_install_assembly_preload_hook);
159  LOAD_MONO_FUNCTION(mono_jit_exec);
160  LOAD_MONO_FUNCTION(mono_jit_init);
161  LOAD_MONO_FUNCTION(mono_jit_set_trace_options);
162  LOAD_MONO_FUNCTION(mono_marshal_get_vtfixup_ftnptr);
163  LOAD_MONO_FUNCTION(mono_object_get_domain);
164  LOAD_MONO_FUNCTION(mono_object_new);
165  LOAD_MONO_FUNCTION(mono_object_unbox);
166  LOAD_MONO_FUNCTION(mono_profiler_install);
167  LOAD_MONO_FUNCTION(mono_reflection_type_from_name);
168  LOAD_MONO_FUNCTION(mono_runtime_invoke);
169  LOAD_MONO_FUNCTION(mono_runtime_object_init);
170  LOAD_MONO_FUNCTION(mono_runtime_quit);
171  LOAD_MONO_FUNCTION(mono_set_dirs);
172  LOAD_MONO_FUNCTION(mono_stringify_assembly_name);
173  LOAD_MONO_FUNCTION(mono_string_new);
174  LOAD_MONO_FUNCTION(mono_thread_attach);
175 
176  /* GLib imports obsoleted by the 2.0 ABI */
177  if (This->mono_abi_version == 1)
178  {
179  (*result)->glib_handle = LoadLibraryW(glibdll);
180  if (!(*result)->glib_handle) goto fail;
181 
182  (*result)->mono_free = (void*)GetProcAddress((*result)->glib_handle, "g_free");
183  if (!(*result)->mono_free) goto fail;
184  }
185  else
186  {
187  LOAD_MONO_FUNCTION(mono_free);
188  }
189 
190 #undef LOAD_MONO_FUNCTION
191 
192 #define LOAD_OPT_VOID_MONO_FUNCTION(x) do { \
193  (*result)->x = (void*)GetProcAddress((*result)->mono_handle, #x); \
194  if (!(*result)->x) { \
195  (*result)->x = do_nothing; \
196  } \
197 } while (0);
198 
199  LOAD_OPT_VOID_MONO_FUNCTION(mono_runtime_set_shutting_down);
200  LOAD_OPT_VOID_MONO_FUNCTION(mono_thread_pool_cleanup);
201  LOAD_OPT_VOID_MONO_FUNCTION(mono_thread_suspend_all_other_threads);
202  LOAD_OPT_VOID_MONO_FUNCTION(mono_threads_set_shutting_down);
203 
204 #undef LOAD_OPT_VOID_MONO_FUNCTION
205 
206  (*result)->mono_profiler_install((MonoProfiler*)*result, mono_shutdown_callback_fn);
207 
208  (*result)->mono_set_dirs(mono_lib_path_a, mono_etc_path_a);
209 
210  (*result)->mono_config_parse(NULL);
211 
212  (*result)->mono_install_assembly_preload_hook(mono_assembly_search_hook_fn, *result);
213 
214  trace_size = GetEnvironmentVariableA("WINE_MONO_TRACE", trace_setting, sizeof(trace_setting));
215 
216  if (trace_size)
217  {
218  (*result)->mono_jit_set_trace_options(trace_setting);
219  }
220  }
221 
222  return S_OK;
223 
224 fail:
225  ERR("Could not load Mono into this process\n");
226  FreeLibrary((*result)->mono_handle);
227  FreeLibrary((*result)->glib_handle);
228  (*result)->mono_handle = NULL;
229  (*result)->glib_handle = NULL;
230  return E_FAIL;
231 }
232 
234 {
235  loaded_mono *mono = (loaded_mono*)prof;
236 
237  mono->is_shutdown = TRUE;
238 }
239 
241 {
242  HRESULT hr = S_OK;
243  loaded_mono *ploaded_mono;
244 
245  if (This->loaded_runtime)
246  {
247  *result = This->loaded_runtime;
248  return hr;
249  }
250 
252 
253  hr = load_mono(This, &ploaded_mono);
254 
255  if (SUCCEEDED(hr))
256  hr = RuntimeHost_Construct(This, ploaded_mono, &This->loaded_runtime);
257 
259 
260  if (SUCCEEDED(hr))
261  *result = This->loaded_runtime;
262 
263  return hr;
264 }
265 
267 {
268  int i;
269 
270  for (i=0; i<NUM_ABI_VERSIONS; i++)
271  {
272  loaded_mono *mono = &loaded_monos[i];
273  if (mono->mono_handle && mono->is_started && !mono->is_shutdown)
274  {
275  /* Copied from Mono's ves_icall_System_Environment_Exit */
276  mono->mono_threads_set_shutting_down();
277  mono->mono_runtime_set_shutting_down();
278  mono->mono_thread_pool_cleanup();
279  mono->mono_thread_suspend_all_other_threads();
280  mono->mono_runtime_quit();
281  }
282  }
283 
284  for (i=0; i<NUM_RUNTIMES; i++)
287 }
288 
290 {
291  int i;
292 
293  for (i=0; i<NUM_ABI_VERSIONS; i++)
294  {
295  loaded_mono *mono = &loaded_monos[i];
296  if (mono->mono_handle && mono->is_started && !mono->is_shutdown)
297  {
298  ERR("Process exited with a Mono runtime loaded.\n");
299  return;
300  }
301  }
302 }
303 
305 {
307 }
308 
310  REFIID riid,
311  void **ppvObject)
312 {
313  TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
314 
315  if ( IsEqualGUID( riid, &IID_ICLRRuntimeInfo ) ||
317  {
318  *ppvObject = iface;
319  }
320  else
321  {
322  FIXME("Unsupported interface %s\n", debugstr_guid(riid));
323  return E_NOINTERFACE;
324  }
325 
326  ICLRRuntimeInfo_AddRef( iface );
327 
328  return S_OK;
329 }
330 
332 {
333  return 2;
334 }
335 
337 {
338  return 1;
339 }
340 
342  LPWSTR pwzBuffer, DWORD *pcchBuffer)
343 {
345  DWORD buffer_size = *pcchBuffer;
346  HRESULT hr = S_OK;
347  char version[11];
348  DWORD size;
349 
350  TRACE("%p %p %p\n", iface, pwzBuffer, pcchBuffer);
351 
352  size = snprintf(version, sizeof(version), "v%u.%u.%u", This->major, This->minor, This->build);
353 
354  assert(size <= sizeof(version));
355 
356  *pcchBuffer = MultiByteToWideChar(CP_UTF8, 0, version, -1, NULL, 0);
357 
358  if (pwzBuffer)
359  {
360  if (buffer_size >= *pcchBuffer)
361  MultiByteToWideChar(CP_UTF8, 0, version, -1, pwzBuffer, buffer_size);
362  else
364  }
365 
366  return hr;
367 }
368 
369 static BOOL get_install_root(LPWSTR install_dir)
370 {
371  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};
372  const WCHAR install_root[] = {'I','n','s','t','a','l','l','R','o','o','t',0};
373 
374  DWORD len;
375  HKEY key;
376 
377  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, dotnet_key, 0, KEY_READ, &key))
378  return FALSE;
379 
380  len = MAX_PATH;
381  if (RegQueryValueExW(key, install_root, 0, NULL, (LPBYTE)install_dir, &len))
382  {
383  RegCloseKey(key);
384  return FALSE;
385  }
386  RegCloseKey(key);
387 
388  return TRUE;
389 }
390 
392  LPWSTR pwzBuffer, DWORD *pcchBuffer)
393 {
394  static const WCHAR slash[] = {'\\',0};
395  DWORD buffer_size = *pcchBuffer;
396  WCHAR system_dir[MAX_PATH];
398  DWORD version_size, size;
399  HRESULT hr = S_OK;
400 
401  TRACE("%p %p %p\n", iface, pwzBuffer, pcchBuffer);
402 
403  if (!get_install_root(system_dir))
404  {
405  ERR("error reading registry key for installroot\n");
406  return E_FAIL;
407  }
408  else
409  {
410  version_size = MAX_PATH;
411  ICLRRuntimeInfo_GetVersionString(iface, version, &version_size);
412  lstrcatW(system_dir, version);
413  lstrcatW(system_dir, slash);
414  size = lstrlenW(system_dir) + 1;
415  }
416 
417  *pcchBuffer = size;
418 
419  if (pwzBuffer)
420  {
421  if (buffer_size >= size)
422  strcpyW(pwzBuffer, system_dir);
423  else
425  }
426 
427  return hr;
428 }
429 
431  HANDLE hndProcess, BOOL *pbLoaded)
432 {
433  FIXME("%p %p %p\n", iface, hndProcess, pbLoaded);
434 
435  return E_NOTIMPL;
436 }
437 
439  UINT iResourceID, LPWSTR pwzBuffer, DWORD *pcchBuffer, LONG iLocaleid)
440 {
441  FIXME("%p %u %p %p %x\n", iface, iResourceID, pwzBuffer, pcchBuffer, iLocaleid);
442 
443  return E_NOTIMPL;
444 }
445 
447  LPCWSTR pwzDllName, HMODULE *phndModule)
448 {
450  HRESULT hr;
452 
453  TRACE("%p %s %p\n", iface, debugstr_w(pwzDllName), phndModule);
454 
456  hr = ICLRRuntimeInfo_GetVersionString(iface, version, &cchBuffer);
457  if (FAILED(hr)) return hr;
458 
459  return LoadLibraryShim(pwzDllName, version, NULL, phndModule);
460 }
461 
463  LPCSTR pszProcName, LPVOID *ppProc)
464 {
465  FIXME("%p %s %p\n", iface, debugstr_a(pszProcName), ppProc);
466 
467  return E_NOTIMPL;
468 }
469 
471  REFCLSID rclsid, REFIID riid, LPVOID *ppUnk)
472 {
474  RuntimeHost *host;
475  HRESULT hr;
476 
477  TRACE("%p %s %s %p\n", iface, debugstr_guid(rclsid), debugstr_guid(riid), ppUnk);
478 
480 
481  if (SUCCEEDED(hr))
482  hr = RuntimeHost_GetInterface(host, rclsid, riid, ppUnk);
483 
484  return hr;
485 }
486 
488  BOOL *pbLoadable)
489 {
490  FIXME("%p %p\n", iface, pbLoadable);
491 
492  return E_NOTIMPL;
493 }
494 
496  DWORD dwStartupFlags, LPCWSTR pwzHostConfigFile)
497 {
498  FIXME("%p %x %s\n", iface, dwStartupFlags, debugstr_w(pwzHostConfigFile));
499 
500  return E_NOTIMPL;
501 }
502 
504  DWORD *pdwStartupFlags, LPWSTR pwzHostConfigFile, DWORD *pcchHostConfigFile)
505 {
506  FIXME("%p %p %p %p\n", iface, pdwStartupFlags, pwzHostConfigFile, pcchHostConfigFile);
507 
508  return E_NOTIMPL;
509 }
510 
512 {
513  FIXME("%p\n", iface);
514 
515  return E_NOTIMPL;
516 }
517 
519  BOOL *pbStarted, DWORD *pdwStartupFlags)
520 {
521  FIXME("%p %p %p\n", iface, pbStarted, pdwStartupFlags);
522 
523  return E_NOTIMPL;
524 }
525 
526 static const struct ICLRRuntimeInfoVtbl CLRRuntimeInfoVtbl = {
542 };
543 
545 {
547 
548  assert(This->ICLRRuntimeInfo_iface.lpVtbl == &CLRRuntimeInfoVtbl);
549 
551 }
552 
553 #ifdef __i386__
554 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};
555 #elif defined(__x86_64__)
556 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};
557 #else
558 static const WCHAR libmono2_arch_dll[] = {'\\','b','i','n','\\','l','i','b','m','o','n','o','-','2','.','0','.','d','l','l',0};
559 #endif
560 
561 static BOOL find_mono_dll(LPCWSTR path, LPWSTR dll_path, int abi_version)
562 {
563  static const WCHAR mono_dll[] = {'\\','b','i','n','\\','m','o','n','o','.','d','l','l',0};
564  static const WCHAR libmono_dll[] = {'\\','b','i','n','\\','l','i','b','m','o','n','o','.','d','l','l',0};
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  if (abi_version == 1)
570  {
571  strcpyW(dll_path, path);
572  strcatW(dll_path, mono_dll);
573  attributes = GetFileAttributesW(dll_path);
574 
575  if (attributes == INVALID_FILE_ATTRIBUTES)
576  {
577  strcpyW(dll_path, path);
578  strcatW(dll_path, libmono_dll);
579  attributes = GetFileAttributesW(dll_path);
580  }
581  }
582  else if (abi_version == 2)
583  {
584  strcpyW(dll_path, path);
585  strcatW(dll_path, libmono2_arch_dll);
586  attributes = GetFileAttributesW(dll_path);
587 
588  if (attributes == INVALID_FILE_ATTRIBUTES)
589  {
590  strcpyW(dll_path, path);
591  strcatW(dll_path, mono2_dll);
592  attributes = GetFileAttributesW(dll_path);
593  }
594 
595  if (attributes == INVALID_FILE_ATTRIBUTES)
596  {
597  strcpyW(dll_path, path);
598  strcatW(dll_path, libmono2_dll);
599  attributes = GetFileAttributesW(dll_path);
600  }
601  }
602 
603  return (attributes != INVALID_FILE_ATTRIBUTES);
604 }
605 
606 static BOOL get_mono_path_from_registry(LPWSTR path, int abi_version)
607 {
608  static const WCHAR mono_key[] = {'S','o','f','t','w','a','r','e','\\','N','o','v','e','l','l','\\','M','o','n','o',0};
609  static const WCHAR defaul_clr[] = {'D','e','f','a','u','l','t','C','L','R',0};
610  static const WCHAR install_root[] = {'S','d','k','I','n','s','t','a','l','l','R','o','o','t',0};
611  static const WCHAR slash[] = {'\\',0};
612 
613  WCHAR version[64], version_key[MAX_PATH];
614  DWORD len;
615  HKEY key;
616  WCHAR dll_path[MAX_PATH];
617 
618  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, mono_key, 0, KEY_READ, &key))
619  return FALSE;
620 
621  len = sizeof(version);
622  if (RegQueryValueExW(key, defaul_clr, 0, NULL, (LPBYTE)version, &len))
623  {
624  RegCloseKey(key);
625  return FALSE;
626  }
627  RegCloseKey(key);
628 
629  lstrcpyW(version_key, mono_key);
630  lstrcatW(version_key, slash);
631  lstrcatW(version_key, version);
632 
633  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, version_key, 0, KEY_READ, &key))
634  return FALSE;
635 
636  len = sizeof(WCHAR) * MAX_PATH;
637  if (RegQueryValueExW(key, install_root, 0, NULL, (LPBYTE)path, &len))
638  {
639  RegCloseKey(key);
640  return FALSE;
641  }
642  RegCloseKey(key);
643 
644  return find_mono_dll(path, dll_path, abi_version);
645 }
646 
648 {
649  static const WCHAR mono_one_dot_zero[] = {'\\','m','o','n','o','-','1','.','0', 0};
650  static const WCHAR mono_two_dot_zero[] = {'\\','m','o','n','o','-','2','.','0', 0};
651  WCHAR mono_dll_path[MAX_PATH];
652  BOOL found = FALSE;
653 
655 
656  if (abi_version == 1)
657  strcatW(mono_path, mono_one_dot_zero);
658  else if (abi_version == 2)
659  strcatW(mono_path, mono_two_dot_zero);
660 
661  found = find_mono_dll(mono_path, mono_dll_path, abi_version);
662 
663  return found;
664 }
665 
666 static BOOL get_mono_path(LPWSTR path, int abi_version)
667 {
668  static const WCHAR subdir_mono[] = {'\\','m','o','n','o',0};
669  static const WCHAR sibling_mono[] = {'\\','.','.','\\','m','o','n','o',0};
670  WCHAR base_path[MAX_PATH];
671  const char *unix_data_dir;
672  WCHAR *dos_data_dir;
673  int build_tree=0;
674  static WCHAR* (CDECL *wine_get_dos_file_name)(const char*);
675 
676  /* First try c:\windows\mono */
677  GetWindowsDirectoryW(base_path, MAX_PATH);
678  strcatW(base_path, subdir_mono);
679 
680  if (get_mono_path_from_folder(base_path, path, abi_version))
681  return TRUE;
682 
683  /* Next: /usr/share/wine/mono */
684  unix_data_dir = wine_get_data_dir();
685 
686  if (!unix_data_dir)
687  {
688  unix_data_dir = wine_get_build_dir();
689  build_tree = 1;
690  }
691 
692  if (unix_data_dir)
693  {
694  if (!wine_get_dos_file_name)
695  wine_get_dos_file_name = (void*)GetProcAddress(GetModuleHandleA("kernel32"), "wine_get_dos_file_name");
696 
697  if (wine_get_dos_file_name)
698  {
699  dos_data_dir = wine_get_dos_file_name(unix_data_dir);
700 
701  if (dos_data_dir)
702  {
703  strcpyW(base_path, dos_data_dir);
704  strcatW(base_path, build_tree ? sibling_mono : subdir_mono);
705 
706  HeapFree(GetProcessHeap(), 0, dos_data_dir);
707 
708  if (get_mono_path_from_folder(base_path, path, abi_version))
709  return TRUE;
710  }
711  }
712  }
713 
714  /* Last: the registry */
715  return get_mono_path_from_registry(path, abi_version);
716 }
717 
718 static void find_runtimes(void)
719 {
720  int abi_version, i;
721  static const WCHAR libmono[] = {'\\','l','i','b','\\','m','o','n','o','\\',0};
722  static const WCHAR mscorlib[] = {'\\','m','s','c','o','r','l','i','b','.','d','l','l',0};
723  WCHAR mono_path[MAX_PATH], lib_path[MAX_PATH];
724  BOOL any_runtimes_found = FALSE;
725 
726  if (runtimes_initialized) return;
727 
729 
730  if (runtimes_initialized) goto end;
731 
732  for (abi_version=NUM_ABI_VERSIONS; abi_version>0; abi_version--)
733  {
734  if (!get_mono_path(mono_path, abi_version))
735  continue;
736 
737  for (i=0; i<NUM_RUNTIMES; i++)
738  {
739  if (runtimes[i].mono_abi_version == 0)
740  {
741  strcpyW(lib_path, mono_path);
742  strcatW(lib_path, libmono);
743  strcatW(lib_path, runtimes[i].mono_libdir);
744  strcatW(lib_path, mscorlib);
745 
747  {
748  runtimes[i].mono_abi_version = abi_version;
749 
751  strcpyW(runtimes[i].mscorlib_path, lib_path);
752 
753  any_runtimes_found = TRUE;
754  }
755  }
756  }
757  }
758 
759  if (!any_runtimes_found)
760  {
761  /* Report all runtimes are available if Mono isn't installed.
762  * FIXME: Remove this when Mono is properly packaged. */
763  for (i=0; i<NUM_RUNTIMES; i++)
765  }
766 
768 
769 end:
771 }
772 
774 {
778 };
779 
780 static const struct IEnumUnknownVtbl InstalledRuntimeEnum_Vtbl;
781 
783 {
785 }
786 
788  void **ppvObject)
789 {
790  TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
791 
792  if ( IsEqualGUID( riid, &IID_IEnumUnknown ) ||
794  {
795  *ppvObject = iface;
796  }
797  else
798  {
799  FIXME("Unsupported interface %s\n", debugstr_guid(riid));
800  return E_NOINTERFACE;
801  }
802 
803  IEnumUnknown_AddRef( iface );
804 
805  return S_OK;
806 }
807 
809 {
812 
813  TRACE("(%p) refcount=%u\n", iface, ref);
814 
815  return ref;
816 }
817 
819 {
822 
823  TRACE("(%p) refcount=%u\n", iface, ref);
824 
825  if (ref == 0)
826  {
828  }
829 
830  return ref;
831 }
832 
834  IUnknown **rgelt, ULONG *pceltFetched)
835 {
837  int num_fetched = 0;
838  HRESULT hr=S_OK;
839  IUnknown *item;
840 
841  TRACE("(%p,%u,%p,%p)\n", iface, celt, rgelt, pceltFetched);
842 
843  while (num_fetched < celt)
844  {
845  if (This->pos >= NUM_RUNTIMES)
846  {
847  hr = S_FALSE;
848  break;
849  }
850  if (runtimes[This->pos].mono_abi_version)
851  {
852  item = (IUnknown*)&runtimes[This->pos].ICLRRuntimeInfo_iface;
853  IUnknown_AddRef(item);
854  rgelt[num_fetched] = item;
855  num_fetched++;
856  }
857  This->pos++;
858  }
859 
860  if (pceltFetched)
861  *pceltFetched = num_fetched;
862 
863  return hr;
864 }
865 
867 {
869  int num_fetched = 0;
870  HRESULT hr=S_OK;
871 
872  TRACE("(%p,%u)\n", iface, celt);
873 
874  while (num_fetched < celt)
875  {
876  if (This->pos >= NUM_RUNTIMES)
877  {
878  hr = S_FALSE;
879  break;
880  }
881  if (runtimes[This->pos].mono_abi_version)
882  {
883  num_fetched++;
884  }
885  This->pos++;
886  }
887 
888  return hr;
889 }
890 
892 {
894 
895  TRACE("(%p)\n", iface);
896 
897  This->pos = 0;
898 
899  return S_OK;
900 }
901 
903 {
905  struct InstalledRuntimeEnum *new_enum;
906 
907  TRACE("(%p)\n", iface);
908 
909  new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_enum));
910  if (!new_enum)
911  return E_OUTOFMEMORY;
912 
913  new_enum->IEnumUnknown_iface.lpVtbl = &InstalledRuntimeEnum_Vtbl;
914  new_enum->ref = 1;
915  new_enum->pos = This->pos;
916 
917  *ppenum = &new_enum->IEnumUnknown_iface;
918 
919  return S_OK;
920 }
921 
922 static const struct IEnumUnknownVtbl InstalledRuntimeEnum_Vtbl = {
930 };
931 
933 {
935 };
936 
938 
940  REFIID riid,
941  void **ppvObject)
942 {
943  TRACE("%s %p\n", debugstr_guid(riid), ppvObject);
944 
945  if ( IsEqualGUID( riid, &IID_ICLRMetaHost ) ||
947  {
948  *ppvObject = iface;
949  }
950  else
951  {
952  FIXME("Unsupported interface %s\n", debugstr_guid(riid));
953  return E_NOINTERFACE;
954  }
955 
956  ICLRMetaHost_AddRef( iface );
957 
958  return S_OK;
959 }
960 
962 {
963  return 2;
964 }
965 
967 {
968  return 1;
969 }
970 
972 {
973  *major = 0;
974  *minor = 0;
975  *build = 0;
976 
977  if (version[0] == 'v' || version[0] == 'V')
978  {
979  version++;
980  if (!isdigit(*version))
981  return FALSE;
982 
983  while (isdigit(*version))
984  *major = *major * 10 + (*version++ - '0');
985 
986  if (*version == 0)
987  return TRUE;
988 
989  if (*version++ != '.' || !isdigit(*version))
990  return FALSE;
991 
992  while (isdigit(*version))
993  *minor = *minor * 10 + (*version++ - '0');
994 
995  if (*version == 0)
996  return TRUE;
997 
998  if (*version++ != '.' || !isdigit(*version))
999  return FALSE;
1000 
1001  while (isdigit(*version))
1002  *build = *build * 10 + (*version++ - '0');
1003 
1004  return *version == 0;
1005  }
1006  else
1007  return FALSE;
1008 }
1009 
1011  LPCWSTR pwzVersion, REFIID iid, LPVOID *ppRuntime)
1012 {
1013  int i;
1014  DWORD major, minor, build;
1015 
1016  TRACE("%s %s %p\n", debugstr_w(pwzVersion), debugstr_guid(iid), ppRuntime);
1017 
1018  if (!pwzVersion)
1019  return E_POINTER;
1020 
1021  if (!parse_runtime_version(pwzVersion, &major, &minor, &build))
1022  {
1023  ERR("Cannot parse %s\n", debugstr_w(pwzVersion));
1024  return CLR_E_SHIM_RUNTIME;
1025  }
1026 
1027  find_runtimes();
1028 
1029  for (i=0; i<NUM_RUNTIMES; i++)
1030  {
1031  if (runtimes[i].major == major && runtimes[i].minor == minor &&
1032  runtimes[i].build == build)
1033  {
1034  if (runtimes[i].mono_abi_version)
1035  return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface, iid,
1036  ppRuntime);
1037  else
1038  {
1040  return CLR_E_SHIM_RUNTIME;
1041  }
1042  }
1043  }
1044 
1045  FIXME("Unrecognized version %s\n", debugstr_w(pwzVersion));
1046  return CLR_E_SHIM_RUNTIME;
1047 }
1048 
1050  LPCWSTR pwzFilePath, LPWSTR pwzBuffer, DWORD *pcchBuffer)
1051 {
1052  ASSEMBLY *assembly;
1053  HRESULT hr;
1054  LPSTR version;
1055  ULONG buffer_size=*pcchBuffer;
1056 
1057  TRACE("%s %p %p\n", debugstr_w(pwzFilePath), pwzBuffer, pcchBuffer);
1058 
1059  hr = assembly_create(&assembly, pwzFilePath);
1060 
1061  if (SUCCEEDED(hr))
1062  {
1064 
1065  if (SUCCEEDED(hr))
1066  {
1067  *pcchBuffer = MultiByteToWideChar(CP_UTF8, 0, version, -1, NULL, 0);
1068 
1069  if (pwzBuffer)
1070  {
1071  if (buffer_size >= *pcchBuffer)
1072  MultiByteToWideChar(CP_UTF8, 0, version, -1, pwzBuffer, buffer_size);
1073  else
1075  }
1076  }
1077 
1079  }
1080 
1081  return hr;
1082 }
1083 
1085  IEnumUnknown **ppEnumerator)
1086 {
1087  struct InstalledRuntimeEnum *new_enum;
1088 
1089  TRACE("%p\n", ppEnumerator);
1090 
1091  find_runtimes();
1092 
1093  new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_enum));
1094  if (!new_enum)
1095  return E_OUTOFMEMORY;
1096 
1097  new_enum->IEnumUnknown_iface.lpVtbl = &InstalledRuntimeEnum_Vtbl;
1098  new_enum->ref = 1;
1099  new_enum->pos = 0;
1100 
1101  *ppEnumerator = &new_enum->IEnumUnknown_iface;
1102 
1103  return S_OK;
1104 }
1105 
1107  HANDLE hndProcess, IEnumUnknown **ppEnumerator)
1108 {
1109  FIXME("%p %p\n", hndProcess, ppEnumerator);
1110 
1111  return E_NOTIMPL;
1112 }
1113 
1115  RuntimeLoadedCallbackFnPtr pCallbackFunction)
1116 {
1117  FIXME("%p\n", pCallbackFunction);
1118 
1119  return E_NOTIMPL;
1120 }
1121 
1123  REFIID riid, LPVOID *ppUnk)
1124 {
1125  FIXME("%s %p\n", debugstr_guid(riid), ppUnk);
1126 
1127  return E_NOTIMPL;
1128 }
1129 
1131 {
1132  FIXME("%i: stub\n", iExitCode);
1133 
1134  ExitProcess(iExitCode);
1135 }
1136 
1137 static const struct ICLRMetaHostVtbl CLRMetaHost_vtbl =
1138 {
1149 };
1150 
1151 static struct CLRMetaHost GlobalCLRMetaHost = {
1152  { &CLRMetaHost_vtbl }
1153 };
1154 
1156 {
1157  return ICLRMetaHost_QueryInterface(&GlobalCLRMetaHost.ICLRMetaHost_iface, riid, ppobj);
1158 }
1159 
1160 static MonoAssembly* mono_assembly_search_hook_fn(MonoAssemblyName *aname, char **assemblies_path, void *user_data)
1161 {
1162  loaded_mono *mono = user_data;
1163  HRESULT hr=S_OK;
1165  char *stringname=NULL;
1166  LPWSTR stringnameW;
1167  int stringnameW_size;
1168  IAssemblyCache *asmcache;
1170  WCHAR path[MAX_PATH];
1171  char *pathA;
1173  static WCHAR fusiondll[] = {'f','u','s','i','o','n',0};
1174  HMODULE hfusion=NULL;
1175  static HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache**,DWORD);
1176 
1177  stringname = mono->mono_stringify_assembly_name(aname);
1178 
1179  TRACE("%s\n", debugstr_a(stringname));
1180 
1181  if (!stringname) return NULL;
1182 
1183  /* FIXME: We should search the given paths before the GAC. */
1184 
1185  if (!pCreateAssemblyCache)
1186  {
1187  hr = LoadLibraryShim(fusiondll, NULL, NULL, &hfusion);
1188 
1189  if (SUCCEEDED(hr))
1190  {
1191  pCreateAssemblyCache = (void*)GetProcAddress(hfusion, "CreateAssemblyCache");
1192  if (!pCreateAssemblyCache)
1193  hr = E_FAIL;
1194  }
1195  }
1196 
1197  if (SUCCEEDED(hr))
1198  hr = pCreateAssemblyCache(&asmcache, 0);
1199 
1200  if (SUCCEEDED(hr))
1201  {
1202  stringnameW_size = MultiByteToWideChar(CP_UTF8, 0, stringname, -1, NULL, 0);
1203 
1204  stringnameW = HeapAlloc(GetProcessHeap(), 0, stringnameW_size * sizeof(WCHAR));
1205  if (stringnameW)
1206  MultiByteToWideChar(CP_UTF8, 0, stringname, -1, stringnameW, stringnameW_size);
1207  else
1208  hr = E_OUTOFMEMORY;
1209 
1210  if (SUCCEEDED(hr))
1211  {
1212  info.cbAssemblyInfo = sizeof(info);
1213  info.pszCurrentAssemblyPathBuf = path;
1214  info.cchBuf = MAX_PATH;
1215  path[0] = 0;
1216 
1217  hr = IAssemblyCache_QueryAssemblyInfo(asmcache, 0, stringnameW, &info);
1218  }
1219 
1220  HeapFree(GetProcessHeap(), 0, stringnameW);
1221 
1222  IAssemblyCache_Release(asmcache);
1223  }
1224 
1225  if (SUCCEEDED(hr))
1226  {
1227  TRACE("found: %s\n", debugstr_w(path));
1228 
1229  pathA = WtoA(path);
1230 
1231  if (pathA)
1232  {
1233  result = mono->mono_assembly_open(pathA, &stat);
1234 
1235  if (!result)
1236  ERR("Failed to load %s, status=%u\n", debugstr_w(path), stat);
1237 
1238  HeapFree(GetProcessHeap(), 0, pathA);
1239  }
1240  }
1241 
1242  mono->mono_free(stringname);
1243 
1244  return result;
1245 }
1246 
1248  DWORD startup_flags, DWORD runtimeinfo_flags, BOOL legacy, ICLRRuntimeInfo **result)
1249 {
1250  static const WCHAR dotconfig[] = {'.','c','o','n','f','i','g',0};
1251  static const DWORD supported_startup_flags = 0;
1252  static const DWORD supported_runtime_flags = RUNTIME_INFO_UPGRADE_VERSION;
1253  int i;
1254  WCHAR local_version[MAX_PATH];
1255  ULONG local_version_size = MAX_PATH;
1256  WCHAR local_config_file[MAX_PATH];
1257  HRESULT hr;
1258  parsed_config_file parsed_config;
1259 
1260  if (startup_flags & ~supported_startup_flags)
1261  FIXME("unsupported startup flags %x\n", startup_flags & ~supported_startup_flags);
1262 
1263  if (runtimeinfo_flags & ~supported_runtime_flags)
1264  FIXME("unsupported runtimeinfo flags %x\n", runtimeinfo_flags & ~supported_runtime_flags);
1265 
1266  if (exefile && !config_file)
1267  {
1268  strcpyW(local_config_file, exefile);
1269  strcatW(local_config_file, dotconfig);
1270 
1271  config_file = local_config_file;
1272  }
1273 
1274  if (config_file)
1275  {
1276  int found=0;
1277  hr = parse_config_file(config_file, &parsed_config);
1278 
1279  if (SUCCEEDED(hr))
1280  {
1283  {
1284  hr = CLRMetaHost_GetRuntime(0, entry->version, &IID_ICLRRuntimeInfo, (void**)result);
1285  if (SUCCEEDED(hr))
1286  {
1287  found = 1;
1288  break;
1289  }
1290  }
1291  }
1292  else
1293  {
1294  WARN("failed to parse config file %s, hr=%x\n", debugstr_w(config_file), hr);
1295  }
1296 
1297  free_parsed_config_file(&parsed_config);
1298 
1299  if (found)
1300  return S_OK;
1301  }
1302 
1303  if (exefile && !version)
1304  {
1305  hr = CLRMetaHost_GetVersionFromFile(0, exefile, local_version, &local_version_size);
1306 
1307  version = local_version;
1308 
1309  if (FAILED(hr)) return hr;
1310  }
1311 
1312  if (version)
1313  {
1314  hr = CLRMetaHost_GetRuntime(0, version, &IID_ICLRRuntimeInfo, (void**)result);
1315  if(SUCCEEDED(hr))
1316  return hr;
1317  }
1318 
1319  if (runtimeinfo_flags & RUNTIME_INFO_UPGRADE_VERSION)
1320  {
1321  DWORD major, minor, build;
1322 
1323  if (version && !parse_runtime_version(version, &major, &minor, &build))
1324  {
1325  ERR("Cannot parse %s\n", debugstr_w(version));
1326  return CLR_E_SHIM_RUNTIME;
1327  }
1328 
1329  find_runtimes();
1330 
1331  if (legacy)
1332  i = 2;
1333  else
1334  i = NUM_RUNTIMES;
1335 
1336  while (i--)
1337  {
1338  if (runtimes[i].mono_abi_version)
1339  {
1340  /* Must be greater or equal to the version passed in. */
1341  if (!version || ((runtimes[i].major >= major && runtimes[i].minor >= minor && runtimes[i].build >= build) ||
1342  (runtimes[i].major >= major && runtimes[i].minor > minor) ||
1343  (runtimes[i].major > major)))
1344  {
1345  return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface,
1346  &IID_ICLRRuntimeInfo, (void **)result);
1347  }
1348  }
1349  }
1350 
1351  if (legacy)
1353  else
1355 
1356  return CLR_E_SHIM_RUNTIME;
1357  }
1358 
1359  return CLR_E_SHIM_RUNTIME;
1360 }
#define NUM_RUNTIMES
Definition: metahost.c:36
static HRESULT WINAPI CLRRuntimeInfo_IsLoaded(ICLRRuntimeInfo *iface, HANDLE hndProcess, BOOL *pbLoaded)
Definition: metahost.c:430
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
#define E_NOINTERFACE
Definition: winerror.h:2364
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
Definition: fci.c:115
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
#define DWORD_PTR
Definition: treelist.c:76
#define WideCharToMultiByte
Definition: compat.h:101
HRESULT hr
Definition: shlfolder.c:183
#define MESSAGE
Definition: options.h:86
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
WCHAR mono_path[MAX_PATH]
HRESULT ICLRRuntimeInfo_GetRuntimeHost(ICLRRuntimeInfo *iface, RuntimeHost **result)
Definition: metahost.c:544
void unload_all_runtimes(void)
Definition: metahost.c:266
#define KEY_READ
Definition: nt_native.h:1023
GLsizei const GLchar ** path
Definition: glext.h:7234
REFIID riid
Definition: precomp.h:44
HRESULT WINAPI CLRMetaHost_GetVersionFromFile(ICLRMetaHost *iface, LPCWSTR pwzFilePath, LPWSTR pwzBuffer, DWORD *pcchBuffer)
Definition: metahost.c:1049
#define REFCLSID
Definition: guiddef.h:117
HRESULT assembly_get_runtime_version(ASSEMBLY *assembly, LPSTR *version)
Definition: assembly.c:865
static void find_runtimes(void)
Definition: metahost.c:718
static BOOL get_mono_path_from_registry(LPWSTR path, int abi_version)
Definition: metahost.c:606
#define WARN(fmt,...)
Definition: debug.h:111
static BOOL get_install_root(LPWSTR install_dir)
Definition: metahost.c:369
HRESULT RuntimeHost_Destroy(RuntimeHost *This)
char * host
Definition: whois.c:55
static HRESULT WINAPI CLRRuntimeInfo_LoadErrorString(ICLRRuntimeInfo *iface, UINT iResourceID, LPWSTR pwzBuffer, DWORD *pcchBuffer, LONG iLocaleid)
Definition: metahost.c:438
#define snprintf
Definition: wintirpc.h:48
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1487
#define assert(x)
Definition: debug.h:53
GLuint GLuint end
Definition: gl.h:1545
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static HRESULT WINAPI CLRRuntimeInfo_GetProcAddress(ICLRRuntimeInfo *iface, LPCSTR pszProcName, LPVOID *ppProc)
Definition: metahost.c:462
static HRESULT WINAPI CLRMetaHost_EnumerateLoadedRuntimes(ICLRMetaHost *iface, HANDLE hndProcess, IEnumUnknown **ppEnumerator)
Definition: metahost.c:1106
char * LPSTR
Definition: xmlstorage.h:182
static HRESULT WINAPI CLRRuntimeInfo_IsStarted(ICLRRuntimeInfo *iface, BOOL *pbStarted, DWORD *pdwStartupFlags)
Definition: metahost.c:518
#define lstrlenW
Definition: compat.h:415
#define E_FAIL
Definition: ddrawi.h:102
static struct _tagASSEMBLY assembly
#define DWORD
Definition: nt_native.h:44
Definition: send.c:47
static CRITICAL_SECTION_DEBUG runtime_list_cs_debug
Definition: metahost.c:47
UINT WINAPI GetWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2351
static ULONG WINAPI CLRRuntimeInfo_AddRef(ICLRRuntimeInfo *iface)
Definition: metahost.c:331
struct _test_info info[]
Definition: SetCursorPos.c:19
HMODULE mono_handle
static const WCHAR net_40_subdir[]
Definition: metahost.c:32
WCHAR mscorlib_path[MAX_PATH]
static CRITICAL_SECTION runtime_list_cs
Definition: metahost.c:46
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static HRESULT WINAPI InstalledRuntimeEnum_Reset(IEnumUnknown *iface)
Definition: metahost.c:891
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
static const struct ICLRMetaHostVtbl CLRMetaHost_vtbl
Definition: metahost.c:1137
#define CP_UTF8
Definition: nls.h:20
static void CDECL do_nothing(void)
Definition: metahost.c:81
MonoAssembly *CDECL * mono_assembly_open(const char *filename, MonoImageOpenStatus *status)
unsigned int BOOL
Definition: ntddk_ex.h:94
static ULONG WINAPI CLRMetaHost_Release(ICLRMetaHost *iface)
Definition: metahost.c:966
long LONG
Definition: pedump.c:60
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:802
static struct CLRRuntimeInfo runtimes[NUM_RUNTIMES]
Definition: metahost.c:38
struct _MonoAssemblyName MonoAssemblyName
#define debugstr_w
Definition: kernel32.h:32
static DWORD cchBuffer
Definition: fusion.c:85
GLenum GLint ref
Definition: glext.h:6028
static HRESULT WINAPI InstalledRuntimeEnum_Next(IEnumUnknown *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
Definition: metahost.c:833
#define FIXME(fmt,...)
Definition: debug.h:110
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:927
#define S_FALSE
Definition: winerror.h:2357
static const struct IEnumUnknownVtbl InstalledRuntimeEnum_Vtbl
Definition: metahost.c:780
IEnumUnknown IEnumUnknown_iface
Definition: metahost.c:775
#define LoadLibraryW(x)
Definition: compat.h:412
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR version[]
Definition: asmname.c:66
static HRESULT WINAPI CLRRuntimeInfo_GetRuntimeDirectory(ICLRRuntimeInfo *iface, LPWSTR pwzBuffer, DWORD *pcchBuffer)
Definition: metahost.c:391
static BOOL find_mono_dll(LPCWSTR path, LPWSTR dll_path, int abi_version)
Definition: metahost.c:561
static BOOL get_mono_path(LPWSTR path, int abi_version)
Definition: metahost.c:666
const char * LPCSTR
Definition: xmlstorage.h:183
#define debugstr_guid
Definition: kernel32.h:35
char *CDECL * mono_stringify_assembly_name(MonoAssemblyName *aname)
#define isdigit(c)
Definition: acclib.h:68
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define CLR_E_SHIM_RUNTIME
Definition: corerror.h:127
static ULONG WINAPI InstalledRuntimeEnum_Release(IEnumUnknown *iface)
Definition: metahost.c:818
static HRESULT(WINAPI *pCLRCreateInstance)(REFCLSID clsid
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:413
#define LOAD_MONO_FUNCTION(x)
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define GetEnvironmentVariableA(x, y, z)
Definition: compat.h:419
void free_parsed_config_file(parsed_config_file *file)
Definition: config.c:448
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:77
void(__stdcall * RuntimeLoadedCallbackFnPtr)(ICLRRuntimeInfo *pRuntimeInfo, CallbackThreadSetFnPtr pfnCallbackThreadSet, CallbackThreadUnsetFnPtr pfnCallbackThreadUnset)
Definition: metahost.idl:88
const GUID IID_IUnknown
struct list supported_runtimes
HRESULT CLRMetaHost_CreateInstance(REFIID riid, void **ppobj)
Definition: metahost.c:1155
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
unsigned long DWORD
Definition: ntddk_ex.h:95
const char * wine_get_build_dir(void)
Definition: config.c:30
static void set_environment(LPCWSTR bin_path)
Definition: metahost.c:66
static void mono_shutdown_callback_fn(MonoProfiler *prof)
Definition: metahost.c:233
ICLRMetaHost ICLRMetaHost_iface
Definition: metahost.c:934
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
static HRESULT WINAPI CLRMetaHost_QueryLegacyV2RuntimeBinding(ICLRMetaHost *iface, REFIID riid, LPVOID *ppUnk)
Definition: metahost.c:1122
BOOL WINAPI DECLSPEC_HOTPATCH SetEnvironmentVariableW(IN LPCWSTR lpName, IN LPCWSTR lpValue)
Definition: environ.c:259
static HRESULT WINAPI CLRMetaHost_QueryInterface(ICLRMetaHost *iface, REFIID riid, void **ppvObject)
Definition: metahost.c:939
static loaded_mono loaded_monos[NUM_ABI_VERSIONS]
Definition: metahost.c:58
HRESULT assembly_create(ASSEMBLY **out, LPCWSTR file)
Definition: assembly.c:641
#define InterlockedDecrement
Definition: armddk.h:52
static HRESULT WINAPI InstalledRuntimeEnum_Skip(IEnumUnknown *iface, ULONG celt)
Definition: metahost.c:866
static HRESULT WINAPI CLRRuntimeInfo_GetVersionString(ICLRRuntimeInfo *iface, LPWSTR pwzBuffer, DWORD *pcchBuffer)
Definition: metahost.c:341
static HRESULT WINAPI CLRRuntimeInfo_GetInterface(ICLRRuntimeInfo *iface, REFCLSID rclsid, REFIID riid, LPVOID *ppUnk)
Definition: metahost.c:470
HRESULT parse_config_file(LPCWSTR filename, parsed_config_file *result)
Definition: config.c:419
HKEY key
Definition: reg.c:42
static ULONG WINAPI InstalledRuntimeEnum_AddRef(IEnumUnknown *iface)
Definition: metahost.c:808
Definition: stat.h:55
uint32_t entry
Definition: isohybrid.c:63
static HRESULT WINAPI CLRRuntimeInfo_LoadLibrary(ICLRRuntimeInfo *iface, LPCWSTR pwzDllName, HMODULE *phndModule)
Definition: metahost.c:446
GLenum GLsizei len
Definition: glext.h:6722
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:821
static void missing_runtime_message(const CLRRuntimeInfo *This)
Definition: metahost.c:85
REFIID LPVOID * ppvObject
Definition: precomp.h:44
static struct InstalledRuntimeEnum * impl_from_IEnumUnknown(IEnumUnknown *iface)
Definition: metahost.c:782
LIST_ENTRY ProcessLocksList
Definition: winbase.h:855
const GUID IID_IEnumUnknown
HRESULT RuntimeHost_Construct(const CLRRuntimeInfo *runtime_version, loaded_mono *loaded_mono, RuntimeHost **result)
static HRESULT WINAPI CLRMetaHost_ExitProcess(ICLRMetaHost *iface, INT32 iExitCode)
Definition: metahost.c:1130
static const struct ICLRRuntimeInfoVtbl CLRRuntimeInfoVtbl
Definition: metahost.c:34
static HRESULT WINAPI CLRRuntimeInfo_BindAsLegacyV2Runtime(ICLRRuntimeInfo *iface)
Definition: metahost.c:511
static HRESULT WINAPI InstalledRuntimeEnum_QueryInterface(IEnumUnknown *iface, REFIID riid, void **ppvObject)
Definition: metahost.c:787
HRESULT assembly_release(ASSEMBLY *assembly)
Definition: assembly.c:694
#define ERR(fmt,...)
Definition: debug.h:109
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
static HRESULT WINAPI CLRRuntimeInfo_IsLoadable(ICLRRuntimeInfo *iface, BOOL *pbLoadable)
Definition: metahost.c:487
#define S_OK
Definition: intsafe.h:59
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
#define InterlockedIncrement
Definition: armddk.h:53
static ATOM item
Definition: dde.c:856
#define lstrcpyW
Definition: compat.h:414
#define CDECL
Definition: compat.h:21
struct _MonoProfiler MonoProfiler
#define major(rdev)
Definition: propsheet.cpp:916
char * WtoA(LPCWSTR wstr)
Definition: mscoree_main.c:30
static HRESULT WINAPI InstalledRuntimeEnum_Clone(IEnumUnknown *iface, IEnumUnknown **ppenum)
Definition: metahost.c:902
#define E_NOTIMPL
Definition: ddrawi.h:99
static HRESULT WINAPI CLRRuntimeInfo_QueryInterface(ICLRRuntimeInfo *iface, REFIID riid, void **ppvObject)
Definition: metahost.c:309
WINE_UNICODE_INLINE WCHAR * strcatW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:242
static ULONG WINAPI CLRRuntimeInfo_Release(ICLRRuntimeInfo *iface)
Definition: metahost.c:336
static MonoAssembly * mono_assembly_search_hook_fn(MonoAssemblyName *aname, char **assemblies_path, void *user_data)
Definition: metahost.c:1160
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
#define NUM_ABI_VERSIONS
Definition: metahost.c:56
#define LOAD_OPT_VOID_MONO_FUNCTION(x)
HRESULT get_runtime_info(LPCWSTR exefile, LPCWSTR version, LPCWSTR config_file, DWORD startup_flags, DWORD runtimeinfo_flags, BOOL legacy, ICLRRuntimeInfo **result)
Definition: metahost.c:1247
HRESULT WINAPI CLRMetaHost_GetRuntime(ICLRMetaHost *iface, LPCWSTR pwzVersion, REFIID iid, LPVOID *ppRuntime)
Definition: metahost.c:1010
#define MultiByteToWideChar
Definition: compat.h:100
static const WCHAR net_11_subdir[]
Definition: metahost.c:30
static struct _PeImage bin
static HRESULT WINAPI CLRMetaHost_EnumerateInstalledRuntimes(ICLRMetaHost *iface, IEnumUnknown **ppEnumerator)
Definition: metahost.c:1084
void expect_no_runtimes(void)
Definition: metahost.c:289
static struct CLRMetaHost GlobalCLRMetaHost
Definition: metahost.c:937
static BOOL get_mono_path_from_folder(LPCWSTR folder, LPWSTR mono_path, int abi_version)
Definition: metahost.c:647
static CLRRuntimeInfo * impl_from_ICLRRuntimeInfo(ICLRRuntimeInfo *iface)
Definition: metahost.c:304
static HRESULT WINAPI CLRRuntimeInfo_GetDefaultStartupFlags(ICLRRuntimeInfo *iface, DWORD *pdwStartupFlags, LPWSTR pwzHostConfigFile, DWORD *pcchHostConfigFile)
Definition: metahost.c:503
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
#define minor(rdev)
Definition: propsheet.cpp:917
GLuint pathA
Definition: glext.h:11719
signed int INT32
MonoImageOpenStatus
struct RuntimeHost * loaded_runtime
#define GetProcAddress(x, y)
Definition: compat.h:418
HRESULT RuntimeHost_GetInterface(RuntimeHost *This, REFCLSID clsid, REFIID riid, void **ppv)
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
struct _MonoAssembly MonoAssembly
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define E_POINTER
Definition: winerror.h:2365
#define GetEnvironmentVariableW(x, y, z)
Definition: compat.h:420
static int runtimes_initialized
Definition: metahost.c:44
static BOOL parse_runtime_version(LPCWSTR version, DWORD *major, DWORD *minor, DWORD *build)
Definition: metahost.c:971
GLuint64EXT * result
Definition: glext.h:11304
void build_tree(deflate_state *s, tree_desc *desc)
Definition: trees.c:615
static HRESULT load_mono(CLRRuntimeInfo *This, loaded_mono **result)
Definition: metahost.c:95
BOOL legacy
Definition: mkisofs.c:131
ICLRRuntimeInfo ICLRRuntimeInfo_iface
#define HeapFree(x, y, z)
Definition: compat.h:402
static HRESULT CLRRuntimeInfo_GetRuntimeHost(CLRRuntimeInfo *This, RuntimeHost **result)
Definition: metahost.c:240
static const WCHAR libmono2_arch_dll[]
Definition: metahost.c:558
const char * wine_get_data_dir(void)
Definition: config.c:24
HRESULT WINAPI LoadLibraryShim(LPCWSTR szDllName, LPCWSTR szVersion, LPVOID pvReserved, HMODULE *phModDll)
Definition: mscoree_main.c:351
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static const WCHAR net_20_subdir[]
Definition: metahost.c:31
static HRESULT WINAPI CLRRuntimeInfo_SetDefaultStartupFlags(ICLRRuntimeInfo *iface, DWORD dwStartupFlags, LPCWSTR pwzHostConfigFile)
Definition: metahost.c:495
static HRESULT WINAPI CLRMetaHost_RequestRuntimeLoadedNotification(ICLRMetaHost *iface, RuntimeLoadedCallbackFnPtr pCallbackFunction)
Definition: metahost.c:1114
Definition: path.c:42
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
static ULONG WINAPI CLRMetaHost_AddRef(ICLRMetaHost *iface)
Definition: metahost.c:961
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10