From 061d7e4c8f8ea14cc35c5726ac25a48c72cdf727 Mon Sep 17 00:00:00 2001 From: Vincent Povirk Date: Tue, 3 Aug 2010 16:26:11 -0500 Subject: [PATCH 3/3] mscoree: Implement ClrCreateManagedInstance. --- dlls/mscoree/mscoree_main.c | 202 +++++++++++++++++++++++++++++++++++++++- dlls/mscoree/mscoree_private.h | 47 +++++++++- 2 files changed, 246 insertions(+), 3 deletions(-) diff --git a/dlls/mscoree/mscoree_main.c b/dlls/mscoree/mscoree_main.c index 38f5efc..1613199 100644 --- a/dlls/mscoree/mscoree_main.c +++ b/dlls/mscoree/mscoree_main.c @@ -21,6 +21,8 @@ #include +#define COBJMACROS + #include "wine/unicode.h" #include "windef.h" #include "winbase.h" @@ -116,12 +118,23 @@ HMODULE mono_handle; MonoDomain *default_domain; +MonoImage* (*mono_assembly_get_image)(MonoAssembly *assembly); +MonoAssembly* (*mono_assembly_load)(MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status); +MonoAssembly* (*mono_assembly_loaded)(MonoAssemblyName *aname); +MonoClass* (*mono_class_from_name)(MonoImage *image, const char* name_space, const char *name); +MonoMethod* (*mono_class_get_method_from_name)(MonoClass *klass, const char *name, int param_count); void (*mono_config_parse)(const char *filename); MonoAssembly* (*mono_domain_assembly_open) (MonoDomain *domain, const char *name); void (*mono_jit_cleanup)(MonoDomain *domain); int (*mono_jit_exec)(MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]); MonoDomain* (*mono_jit_init)(const char *file); int (*mono_jit_set_trace_options)(const char* options); +MonoObject* (*mono_object_new)(MonoDomain *domain, MonoClass *klass); +void* (*mono_object_unbox)(MonoObject *obj); +void (*mono_reflection_free_type_info)(MonoTypeNameParse *info); +int (*mono_reflection_parse_type)(char *name, MonoTypeNameParse *info); +MonoObject* (*mono_runtime_invoke)(MonoMethod *method, void *obj, void **params, MonoObject **exc); +void (*mono_runtime_object_init)(MonoObject *this_obj); void (*mono_set_dirs)(const char *assembly_dir, const char *config_dir); static void set_environment(LPCWSTR bin_path) @@ -192,12 +205,23 @@ static HMODULE load_mono(void) } \ } while (0); + LOAD_MONO_FUNCTION(mono_assembly_get_image); + LOAD_MONO_FUNCTION(mono_assembly_load); + LOAD_MONO_FUNCTION(mono_assembly_loaded); + LOAD_MONO_FUNCTION(mono_class_from_name); + LOAD_MONO_FUNCTION(mono_class_get_method_from_name); LOAD_MONO_FUNCTION(mono_config_parse); LOAD_MONO_FUNCTION(mono_domain_assembly_open); LOAD_MONO_FUNCTION(mono_jit_cleanup); LOAD_MONO_FUNCTION(mono_jit_exec); LOAD_MONO_FUNCTION(mono_jit_init); LOAD_MONO_FUNCTION(mono_jit_set_trace_options); + LOAD_MONO_FUNCTION(mono_object_new); + LOAD_MONO_FUNCTION(mono_object_unbox); + LOAD_MONO_FUNCTION(mono_reflection_free_type_info); + LOAD_MONO_FUNCTION(mono_reflection_parse_type); + LOAD_MONO_FUNCTION(mono_runtime_invoke); + LOAD_MONO_FUNCTION(mono_runtime_object_init); LOAD_MONO_FUNCTION(mono_set_dirs); #undef LOAD_MONO_FUNCTION @@ -320,6 +344,21 @@ static void get_utf8_args(int *argc, char ***argv) HeapFree(GetProcessHeap(), 0, argvw); } +static char *wstr_to_utf8(LPCWSTR wstr) +{ + char *result; + int size; + + size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL); + + result = HeapAlloc(GetProcessHeap(), 0, size); + + if (result) + WideCharToMultiByte(CP_UTF8, 0, wstr, -1, result, size, NULL, NULL); + + return result; +} + __int32 WINAPI _CorExeMain(void) { int exit_code; @@ -554,10 +593,169 @@ HRESULT WINAPI CorBindToCurrentRuntime(LPCWSTR filename, REFCLSID rclsid, REFIID return E_NOTIMPL; } +static HRESULT mono_object_queryinterface(MonoObject *object, REFIID riid, void **ppObject) +{ + IUnknown *punk; + HRESULT hr; + MonoAssembly *assembly; + MonoImage *image; + MonoClass *klass; + MonoMethod *method; + MonoObject *result; + void *args[2]; + + /* The ultimate goal of this exercise is to call + * System.Runtime.InteropServices.Marshal:GetIUnknownForObject */ + assembly = mono_domain_assembly_open(default_domain, "mscorlib"); + if (!assembly) + { + ERR("Cannot load mscorlib\n"); + return E_FAIL; + } + + image = mono_assembly_get_image(assembly); + if (!image) + { + ERR("Couldn't get assembly image\n"); + return E_FAIL; + } + + klass = mono_class_from_name(image, "System.Runtime.InteropServices", "Marshal"); + if (!klass) + { + ERR("Couldn't get class from image\n"); + return E_FAIL; + } + + method = mono_class_get_method_from_name(klass, "GetIUnknownForObject", 1); + if (!method) + { + ERR("Couldn't get method from class\n"); + return E_FAIL; + } + + args[0] = object; + args[1] = NULL; + result = mono_runtime_invoke(method, NULL, args, NULL); + if (!result) + { + ERR("Couldn't get result pointer\n"); + return E_FAIL; + } + + punk = *(IUnknown**)mono_object_unbox(result); + if (!result) + { + ERR("GetIUnknownForObject returned 0\n"); + return E_FAIL; + } + + hr = IUnknown_QueryInterface(punk, riid, ppObject); + + IUnknown_Release(punk); + + TRACE("<-- %08x\n", hr); + + return hr; +} + STDAPI ClrCreateManagedInstance(LPCWSTR pTypeName, REFIID riid, void **ppObject) { - FIXME("(%s,%s,%p)\n", debugstr_w(pTypeName), debugstr_guid(riid), ppObject); - return E_NOTIMPL; + char *typenameA; + MonoTypeNameParse parsed_typename; + HRESULT hr=S_OK; + MonoAssembly *assembly=NULL; + MonoImageOpenStatus open_status; + MonoImage *image; + MonoClass *klass=NULL; + MonoObject *object; + + TRACE("(%s,%s,%p)\n", debugstr_w(pTypeName), debugstr_guid(riid), ppObject); + + if (!load_mono()) + { + return E_FAIL; + } + + if (!default_domain) + { + EnterCriticalSection(&mono_lib_cs); + if (!mono_handle) + { + ERR("CorExitProcess called on another thread?\n"); + return E_FAIL; + } + else if (!default_domain) + /* FIXME: What is the appropriate name for this AppDomain? */ + default_domain = mono_jit_init("default"); + LeaveCriticalSection(&mono_lib_cs); + } + + typenameA = wstr_to_utf8(pTypeName); + if (!typenameA) return E_OUTOFMEMORY; + + if (mono_reflection_parse_type(typenameA, &parsed_typename)) + { + assembly = mono_assembly_loaded(&parsed_typename.assembly); + + if (!assembly) + { + assembly = mono_assembly_load(&parsed_typename.assembly, NULL, &open_status); + } + + if (!assembly) + { + ERR("Cannot load assembly for %s, status=%i\n", debugstr_w(pTypeName), open_status); + hr = E_FAIL; + } + + if (SUCCEEDED(hr)) + { + image = mono_assembly_get_image(assembly); + if (!image) + { + ERR("Couldn't get assembly image\n"); + hr = E_FAIL; + } + } + + if (SUCCEEDED(hr)) + { + klass = mono_class_from_name(image, parsed_typename.name_space, parsed_typename.name); + if (!klass) + { + ERR("Couldn't get class from image\n"); + hr = E_FAIL; + } + } + + mono_reflection_free_type_info(&parsed_typename); + } + else + { + ERR("Invalid typename %s\n", debugstr_w(pTypeName)); + hr = E_INVALIDARG; + } + + HeapFree(GetProcessHeap(), 0, typenameA); + + if (SUCCEEDED(hr)) + { + object = mono_object_new(default_domain, klass); + if (!object) + { + ERR("Couldn't create object\n"); + hr = E_OUTOFMEMORY; + } + } + + if (SUCCEEDED(hr)) + { + /* FIXME: Detect exceptions */ + mono_runtime_object_init(object); + } + + return mono_object_queryinterface(object, riid, ppObject); } BOOL WINAPI StrongNameSignatureVerification(LPCWSTR filename, DWORD inFlags, DWORD* pOutFlags) diff --git a/dlls/mscoree/mscoree_private.h b/dlls/mscoree/mscoree_private.h index f14da1d..c4f4658 100644 --- a/dlls/mscoree/mscoree_private.h +++ b/dlls/mscoree/mscoree_private.h @@ -23,17 +23,62 @@ extern IUnknown* create_corruntimehost(void); /* Mono 2.6 embedding */ -typedef struct _MonoDomain MonoDomain; +#define MONO_PUBLIC_KEY_TOKEN_LENGTH 17 + +typedef enum { + MONO_IMAGE_OK, + MONO_IMAGE_ERROR_ERRNO, + MONO_IMAGE_MISSING_ASSEMBLYREF, + MONO_IMAGE_IMAGE_INVALID +} MonoImageOpenStatus; + typedef struct _MonoAssembly MonoAssembly; +typedef struct _MonoClass MonoClass; +typedef struct _MonoDomain MonoDomain; +typedef struct _MonoImage MonoImage; +typedef struct _MonoMethod MonoMethod; +typedef struct _MonoObject MonoObject; + +typedef struct { + const char *name; + const char *culture; + const char *hash_value; + const char* public_key; + char public_key_token [MONO_PUBLIC_KEY_TOKEN_LENGTH]; + DWORD hash_alg; + DWORD hash_len; + DWORD flags; + WORD major, minor, build, revision; +} MonoAssemblyName; + +typedef struct MonoTypeNameParse { + char *name_space; + char *name; + MonoAssemblyName assembly; + void *modifiers; /* GList* */ + void *type_arguments; /* GPtrArray* */ + void *nested; /* GList* */ +} MonoTypeNameParse; extern HMODULE mono_handle; +extern MonoImage* (*mono_assembly_get_image)(MonoAssembly *assembly); +extern MonoAssembly* (*mono_assembly_load)(MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status); +extern MonoAssembly* (*mono_assembly_loaded)(MonoAssemblyName *aname); +extern MonoClass* (*mono_class_from_name)(MonoImage *image, const char* name_space, const char *name); +extern MonoMethod* (*mono_class_get_method_from_name)(MonoClass *klass, const char *name, int param_count); extern void (*mono_config_parse)(const char *filename); extern MonoAssembly* (*mono_domain_assembly_open) (MonoDomain *domain, const char *name); extern void (*mono_jit_cleanup)(MonoDomain *domain); extern int (*mono_jit_exec)(MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]); extern MonoDomain* (*mono_jit_init)(const char *file); extern int (*mono_jit_set_trace_options)(const char* options); +extern MonoObject* (*mono_object_new)(MonoDomain *domain, MonoClass *klass); +extern void* (*mono_object_unbox)(MonoObject *obj); +extern void (*mono_reflection_free_type_info)(MonoTypeNameParse *info); +extern int (*mono_reflection_parse_type)(char *name, MonoTypeNameParse *info); +extern MonoObject* (*mono_runtime_invoke)(MonoMethod *method, void *obj, void **params, MonoObject **exc); +extern void (*mono_runtime_object_init)(MonoObject *this_obj); extern void (*mono_set_dirs)(const char *assembly_dir, const char *config_dir); #endif /* __MSCOREE_PRIVATE__ */ -- 1.7.0.4