mscoree_private.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <objbase.h>
#include <cor.h>
#include <cordebug.h>
#include <metahost.h>
#include <wine/list.h>
#include <wine/unicode.h>
#include <wine/debug.h>

Include dependency graph for mscoree_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_VTableFixup
struct	CLRRuntimeInfo
struct	RuntimeHost
struct	CorProcess
struct	CorDebug
struct	parsed_config_file
struct	supported_runtime
struct	loaded_mono

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	COBJMACROS

Typedefs
typedef struct _VTableFixup	VTableFixup
typedef struct tagASSEMBLY	ASSEMBLY
typedef struct _MonoDomain	MonoDomain
typedef struct _MonoAssembly	MonoAssembly
typedef struct _MonoAssemblyName	MonoAssemblyName
typedef struct _MonoType	MonoType
typedef struct _MonoImage	MonoImage
typedef struct _MonoClass	MonoClass
typedef struct _MonoObject	MonoObject
typedef struct _MonoString	MonoString
typedef struct _MonoMethod	MonoMethod
typedef struct _MonoProfiler	MonoProfiler
typedef struct _MonoThread	MonoThread
typedef struct loaded_mono	loaded_mono
typedef struct RuntimeHost	RuntimeHost
typedef struct CLRRuntimeInfo	CLRRuntimeInfo
typedef struct CorProcess	CorProcess
typedef struct CorDebug	CorDebug
typedef struct parsed_config_file	parsed_config_file
typedef struct supported_runtime	supported_runtime
typedef MonoAssembly *(*	MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, char **assemblies_path, void *user_data)
typedef void(*	MonoProfileFunc) (MonoProfiler *prof)

Enumerations
enum	MonoImageOpenStatus { MONO_IMAGE_OK , MONO_IMAGE_ERROR_ERRNO , MONO_IMAGE_MISSING_ASSEMBLYREF , MONO_IMAGE_IMAGE_INVALID }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mscoree)
char *	WtoA (LPCWSTR wstr) DECLSPEC_HIDDEN
HRESULT	CLRMetaHost_CreateInstance (REFIID riid, void **ppobj) DECLSPEC_HIDDEN
HRESULT WINAPI	CLRMetaHost_GetVersionFromFile (ICLRMetaHost *iface, LPCWSTR pwzFilePath, LPWSTR pwzBuffer, DWORD *pcchBuffer) DECLSPEC_HIDDEN
HRESULT	assembly_create (ASSEMBLY **out, LPCWSTR file) DECLSPEC_HIDDEN
HRESULT	assembly_from_hmodule (ASSEMBLY **out, HMODULE hmodule) DECLSPEC_HIDDEN
HRESULT	assembly_release (ASSEMBLY *assembly) DECLSPEC_HIDDEN
HRESULT	assembly_get_runtime_version (ASSEMBLY *assembly, LPSTR *version) DECLSPEC_HIDDEN
HRESULT	assembly_get_vtable_fixups (ASSEMBLY *assembly, VTableFixup **fixups, DWORD *count) DECLSPEC_HIDDEN
HRESULT	get_runtime_info (LPCWSTR exefile, LPCWSTR version, LPCWSTR config_file, DWORD startup_flags, DWORD runtimeinfo_flags, BOOL legacy, ICLRRuntimeInfo **result) DECLSPEC_HIDDEN
HRESULT	ICLRRuntimeInfo_GetRuntimeHost (ICLRRuntimeInfo *iface, RuntimeHost **result) DECLSPEC_HIDDEN
HRESULT	MetaDataDispenser_CreateInstance (IUnknown **ppUnk) DECLSPEC_HIDDEN
HRESULT	parse_config_file (LPCWSTR filename, parsed_config_file *result) DECLSPEC_HIDDEN
void	free_parsed_config_file (parsed_config_file *file) DECLSPEC_HIDDEN
void	unload_all_runtimes (void) DECLSPEC_HIDDEN
void	expect_no_runtimes (void) DECLSPEC_HIDDEN
HRESULT	RuntimeHost_Construct (const CLRRuntimeInfo *runtime_version, loaded_mono *loaded_mono, RuntimeHost **result) DECLSPEC_HIDDEN
HRESULT	RuntimeHost_GetInterface (RuntimeHost *This, REFCLSID clsid, REFIID riid, void **ppv) DECLSPEC_HIDDEN
HRESULT	RuntimeHost_GetIUnknownForObject (RuntimeHost *This, MonoObject *obj, IUnknown **ppUnk) DECLSPEC_HIDDEN
HRESULT	RuntimeHost_CreateManagedInstance (RuntimeHost *This, LPCWSTR name, MonoDomain *domain, MonoObject **result) DECLSPEC_HIDDEN
HRESULT	RuntimeHost_Destroy (RuntimeHost *This) DECLSPEC_HIDDEN
HRESULT WINAPI	CLRMetaHost_GetRuntime (ICLRMetaHost *iface, LPCWSTR pwzVersion, REFIID iid, LPVOID *ppRuntime) DECLSPEC_HIDDEN
HRESULT	CorDebug_Create (ICLRRuntimeHost *runtimehost, IUnknown **ppUnk) DECLSPEC_HIDDEN
HRESULT	create_monodata (REFIID riid, LPVOID *ppObj) DECLSPEC_HIDDEN
void	runtimehost_init (void)
void	runtimehost_uninit (void)

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 26 of file mscoree_private.h.

COBJMACROS

#define COBJMACROS

Definition at line 29 of file mscoree_private.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 27 of file mscoree_private.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 25 of file mscoree_private.h.

Typedef Documentation

ASSEMBLY

typedef struct tagASSEMBLY ASSEMBLY

Definition at line 58 of file mscoree_private.h.

CLRRuntimeInfo

typedef struct CLRRuntimeInfo CLRRuntimeInfo

CorDebug

typedef struct CorDebug CorDebug

CorProcess

typedef struct CorProcess CorProcess

loaded_mono

typedef struct loaded_mono loaded_mono

Definition at line 79 of file mscoree_private.h.

MonoAssembly

typedef struct _MonoAssembly MonoAssembly

Definition at line 68 of file mscoree_private.h.

MonoAssemblyName

typedef struct _MonoAssemblyName MonoAssemblyName

Definition at line 69 of file mscoree_private.h.

MonoAssemblyPreLoadFunc

typedef MonoAssembly *(* MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, char **assemblies_path, void *user_data)

Definition at line 158 of file mscoree_private.h.

MonoClass

typedef struct _MonoClass MonoClass

Definition at line 72 of file mscoree_private.h.

MonoDomain

typedef struct _MonoDomain MonoDomain

Definition at line 67 of file mscoree_private.h.

MonoImage

typedef struct _MonoImage MonoImage

Definition at line 71 of file mscoree_private.h.

MonoMethod

typedef struct _MonoMethod MonoMethod

Definition at line 75 of file mscoree_private.h.

MonoObject

typedef struct _MonoObject MonoObject

Definition at line 73 of file mscoree_private.h.

MonoProfileFunc

typedef void(* MonoProfileFunc) (MonoProfiler *prof)

Definition at line 160 of file mscoree_private.h.

MonoProfiler

typedef struct _MonoProfiler MonoProfiler

Definition at line 76 of file mscoree_private.h.

MonoString

typedef struct _MonoString MonoString

Definition at line 74 of file mscoree_private.h.

MonoThread

typedef struct _MonoThread MonoThread

Definition at line 77 of file mscoree_private.h.

MonoType

typedef struct _MonoType MonoType

Definition at line 70 of file mscoree_private.h.

parsed_config_file

typedef struct parsed_config_file parsed_config_file

RuntimeHost

typedef struct RuntimeHost RuntimeHost

Definition at line 80 of file mscoree_private.h.

supported_runtime

typedef struct supported_runtime supported_runtime

VTableFixup

typedef struct _VTableFixup VTableFixup

Enumeration Type Documentation

MonoImageOpenStatus

enum MonoImageOpenStatus

Enumerator
MONO_IMAGE_OK
MONO_IMAGE_ERROR_ERRNO
MONO_IMAGE_MISSING_ASSEMBLYREF
MONO_IMAGE_IMAGE_INVALID

Definition at line 151 of file mscoree_private.h.

             {
    MONO_IMAGE_OK,
    MONO_IMAGE_ERROR_ERRNO,
    MONO_IMAGE_MISSING_ASSEMBLYREF,
    MONO_IMAGE_IMAGE_INVALID
} MonoImageOpenStatus;

Function Documentation

assembly_create()

HRESULT assembly_create	(	ASSEMBLY **	out,
		LPCWSTR	file
	)

Definition at line 641 of file assembly.c.

{
    ASSEMBLY *assembly;
    HRESULT hr;
 
    *out = NULL;
 
    if (!(assembly = heap_alloc_zero(sizeof(*assembly)))) return E_OUTOFMEMORY;
 
    assembly->path = strdupW(file);
    if (!assembly->path)
    {
        hr = E_OUTOFMEMORY;
        goto failed;
    }
 
    assembly->hfile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ,
                                  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (assembly->hfile == INVALID_HANDLE_VALUE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto failed;
    }
 
    assembly->hmap = CreateFileMappingW(assembly->hfile, NULL, PAGE_READONLY,
                                        0, 0, NULL);
    if (!assembly->hmap)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto failed;
    }
 
    assembly->data = MapViewOfFile(assembly->hmap, FILE_MAP_READ, 0, 0, 0);
    if (!assembly->data)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto failed;
    }
 
    hr = parse_pe_header(assembly);
    if (FAILED(hr)) goto failed;
 
    hr = parse_clr_metadata(assembly);
    if (FAILED(hr)) goto failed;
 
    *out = assembly;
    return S_OK;
 
failed:
    assembly_release(assembly);
    return hr;
}

Referenced by CLRMetaHost_GetVersionFromFile(), and IAssemblyCacheImpl_InstallAssembly().

assembly_from_hmodule()

HRESULT assembly_from_hmodule	(	ASSEMBLY **	out,
		HMODULE	hmodule
	)

Definition at line 245 of file assembly.c.

{
    ASSEMBLY *assembly;
    HRESULT hr;
 
    *out = NULL;
 
    assembly = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ASSEMBLY));
    if (!assembly)
        return E_OUTOFMEMORY;
 
    assembly->is_mapped_file = 0;
 
    assembly->data = (BYTE*)hmodule;
 
    hr = parse_headers(assembly);
    if (SUCCEEDED(hr))
        *out = assembly;
    else
        assembly_release(assembly);
 
    return hr;
}

Referenced by FixupVTable().

assembly_get_runtime_version()

HRESULT assembly_get_runtime_version	(	ASSEMBLY *	assembly,
		LPSTR *	version
	)

Definition at line 865 of file assembly.c.

{
    *version = assembly->metadatahdr->Version;
    return S_OK;
}

Referenced by CLRMetaHost_GetVersionFromFile(), and IAssemblyCacheImpl_InstallAssembly().

assembly_get_vtable_fixups()

HRESULT assembly_get_vtable_fixups	(	ASSEMBLY *	assembly,
		VTableFixup **	fixups,
		DWORD *	count
	)

Definition at line 294 of file assembly.c.

{
    ULONG size;
 
    size = assembly_datadir_get_data(assembly, &assembly->corhdr->VTableFixups, (void**)fixups);
    *count = size / sizeof(VTableFixup);
 
    return S_OK;
}

Referenced by FixupVTable().

assembly_release()

HRESULT assembly_release

(

ASSEMBLY *

assembly

)

Definition at line 694 of file assembly.c.

{
    if (!assembly)
        return S_OK;
 
    heap_free(assembly->metadatahdr);
    heap_free(assembly->path);
    UnmapViewOfFile(assembly->data);
    CloseHandle(assembly->hmap);
    CloseHandle(assembly->hfile);
    heap_free(assembly);
 
    return S_OK;
}

Referenced by assembly_create(), assembly_from_hmodule(), CLRMetaHost_GetVersionFromFile(), FixupVTable(), and IAssemblyCacheImpl_InstallAssembly().

CLRMetaHost_CreateInstance()

HRESULT CLRMetaHost_CreateInstance	(	REFIID	riid,
		void **	ppobj
	)

Definition at line 1155 of file metahost.c.

{
    return ICLRMetaHost_QueryInterface(&GlobalCLRMetaHost.ICLRMetaHost_iface, riid, ppobj);
}

Referenced by CLRCreateInstance().

CLRMetaHost_GetRuntime()

HRESULT WINAPI CLRMetaHost_GetRuntime	(	ICLRMetaHost *	iface,
		LPCWSTR	pwzVersion,
		REFIID	iid,
		LPVOID *	ppRuntime
	)

Definition at line 1010 of file metahost.c.

{
    int i;
    DWORD major, minor, build;
 
    TRACE("%s %s %p\n", debugstr_w(pwzVersion), debugstr_guid(iid), ppRuntime);
 
    if (!pwzVersion)
        return E_POINTER;
 
    if (!parse_runtime_version(pwzVersion, &major, &minor, &build))
    {
        ERR("Cannot parse %s\n", debugstr_w(pwzVersion));
        return CLR_E_SHIM_RUNTIME;
    }
 
    find_runtimes();
 
    for (i=0; i<NUM_RUNTIMES; i++)
    {
        if (runtimes[i].major == major && runtimes[i].minor == minor &&
            runtimes[i].build == build)
        {
            if (runtimes[i].mono_abi_version)
                return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface, iid,
                        ppRuntime);
            else
            {
                missing_runtime_message(&runtimes[i]);
                return CLR_E_SHIM_RUNTIME;
            }
        }
    }
 
    FIXME("Unrecognized version %s\n", debugstr_w(pwzVersion));
    return CLR_E_SHIM_RUNTIME;
}

Referenced by CreateDebuggingInterfaceFromVersion(), and get_runtime_info().

CLRMetaHost_GetVersionFromFile()

HRESULT WINAPI CLRMetaHost_GetVersionFromFile	(	ICLRMetaHost *	iface,
		LPCWSTR	pwzFilePath,
		LPWSTR	pwzBuffer,
		DWORD *	pcchBuffer
	)

Definition at line 1049 of file metahost.c.

{
    ASSEMBLY *assembly;
    HRESULT hr;
    LPSTR version;
    ULONG buffer_size=*pcchBuffer;
 
    TRACE("%s %p %p\n", debugstr_w(pwzFilePath), pwzBuffer, pcchBuffer);
 
    hr = assembly_create(&assembly, pwzFilePath);
 
    if (SUCCEEDED(hr))
    {
        hr = assembly_get_runtime_version(assembly, &version);
 
        if (SUCCEEDED(hr))
        {
            *pcchBuffer = MultiByteToWideChar(CP_UTF8, 0, version, -1, NULL, 0);
 
            if (pwzBuffer)
            {
                if (buffer_size >= *pcchBuffer)
                    MultiByteToWideChar(CP_UTF8, 0, version, -1, pwzBuffer, buffer_size);
                else
                    hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
            }
        }
 
        assembly_release(assembly);
    }
 
    return hr;
}

Referenced by get_runtime_info(), and GetFileVersion().

CorDebug_Create()

HRESULT CorDebug_Create	(	ICLRRuntimeHost *	runtimehost,
		IUnknown **	ppUnk
	)

Definition at line 742 of file cordebug.c.

{
    CorDebug *This;
 
    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
    if ( !This )
        return E_OUTOFMEMORY;
 
    This->ICorDebug_iface.lpVtbl = &cordebug_vtbl;
    This->ICorDebugProcessEnum_iface.lpVtbl = &processenum_vtbl;
    This->ref = 1;
    This->pCallback = NULL;
    This->pCallback2 = NULL;
    This->runtimehost = runtimehost;
 
    list_init(&This->processes);
 
    if(This->runtimehost)
        ICLRRuntimeHost_AddRef(This->runtimehost);
 
    *ppUnk = (IUnknown*)&This->ICorDebug_iface;
 
    return S_OK;
}

Referenced by RuntimeHost_GetInterface().

create_monodata()

HRESULT create_monodata	(	REFIID	riid,
		LPVOID *	ppObj
	)

Definition at line 1211 of file corruntimehost.c.

{
    static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0};
    static const WCHAR wszClass[] = {'C','l','a','s','s',0};
    static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0};
    static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
    static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
    WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1];
    MonoDomain *domain;
    MonoAssembly *assembly;
    ICLRRuntimeInfo *info = NULL;
    RuntimeHost *host;
    HRESULT hr;
    HKEY key;
    LONG res;
    int offset = 0;
    WCHAR codebase[MAX_PATH + 8];
    WCHAR classname[350];
    WCHAR filename[MAX_PATH];
 
    DWORD dwBufLen = 350;
 
    lstrcpyW(path, wszCLSIDSlash);
    StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
    lstrcatW(path, wszInprocServer32);
 
    TRACE("Registry key: %s\n", debugstr_w(path));
 
    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key);
    if (res == ERROR_FILE_NOT_FOUND)
        return CLASS_E_CLASSNOTAVAILABLE;
 
    res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen);
    if(res != ERROR_SUCCESS)
    {
        WARN("Class value cannot be found.\n");
        hr = CLASS_E_CLASSNOTAVAILABLE;
        goto cleanup;
    }
 
    TRACE("classname (%s)\n", debugstr_w(classname));
 
    dwBufLen = MAX_PATH + 8;
    res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen);
    if(res != ERROR_SUCCESS)
    {
        WARN("CodeBase value cannot be found.\n");
        hr = CLASS_E_CLASSNOTAVAILABLE;
        goto cleanup;
    }
 
    /* Strip file:/// */
    if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0)
        offset = strlenW(wszFileSlash);
 
    strcpyW(filename, codebase + offset);
 
    TRACE("codebase (%s)\n", debugstr_w(filename));
 
    *ppObj = NULL;
 
 
    hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
    if (SUCCEEDED(hr))
    {
        hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
 
        if (SUCCEEDED(hr))
            hr = RuntimeHost_GetDefaultDomain(host, &domain);
 
        if (SUCCEEDED(hr))
        {
            MonoImage *image;
            MonoClass *klass;
            MonoObject *result;
            IUnknown *unk = NULL;
            char *filenameA, *ns;
            char *classA;
 
            hr = CLASS_E_CLASSNOTAVAILABLE;
 
            host->mono->mono_thread_attach(domain);
 
            filenameA = WtoA(filename);
            assembly = host->mono->mono_domain_assembly_open(domain, filenameA);
            HeapFree(GetProcessHeap(), 0, filenameA);
            if (!assembly)
            {
                ERR("Cannot open assembly %s\n", filenameA);
                goto cleanup;
            }
 
            image = host->mono->mono_assembly_get_image(assembly);
            if (!image)
            {
                ERR("Couldn't get assembly image\n");
                goto cleanup;
            }
 
            classA = WtoA(classname);
            ns = strrchr(classA, '.');
            *ns = '\0';
 
            klass = host->mono->mono_class_from_name(image, classA, ns+1);
            HeapFree(GetProcessHeap(), 0, classA);
            if (!klass)
            {
                ERR("Couldn't get class from image\n");
                goto cleanup;
            }
 
            /*
             * Use the default constructor for the .NET class.
             */
            result = host->mono->mono_object_new(domain, klass);
            host->mono->mono_runtime_object_init(result);
 
            hr = RuntimeHost_GetIUnknownForObject(host, result, &unk);
            if (SUCCEEDED(hr))
            {
                hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj);
 
                IUnknown_Release(unk);
            }
            else
                hr = CLASS_E_CLASSNOTAVAILABLE;
        }
        else
            hr = CLASS_E_CLASSNOTAVAILABLE;
    }
    else
        hr = CLASS_E_CLASSNOTAVAILABLE;
 
cleanup:
    if(info)
        ICLRRuntimeInfo_Release(info);
 
    RegCloseKey(key);
 
    return hr;
}

Referenced by DllGetClassObject().

expect_no_runtimes()

void expect_no_runtimes

(

void

)

Definition at line 289 of file metahost.c.

{
    int i;
 
    for (i=0; i<NUM_ABI_VERSIONS; i++)
    {
        loaded_mono *mono = &loaded_monos[i];
        if (mono->mono_handle && mono->is_started && !mono->is_shutdown)
        {
            ERR("Process exited with a Mono runtime loaded.\n");
            return;
        }
    }
}

Referenced by DllMain().

free_parsed_config_file()

void free_parsed_config_file

(

parsed_config_file *

file

)

Definition at line 448 of file config.c.

{
    supported_runtime *cursor, *cursor2;
 
    LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &file->supported_runtimes, supported_runtime, entry)
    {
        HeapFree(GetProcessHeap(), 0, cursor->version);
        list_remove(&cursor->entry);
        HeapFree(GetProcessHeap(), 0, cursor);
    }
}

Referenced by get_runtime_info().

get_runtime_info()

HRESULT get_runtime_info	(	LPCWSTR	exefile,
		LPCWSTR	version,
		LPCWSTR	config_file,
		DWORD	startup_flags,
		DWORD	runtimeinfo_flags,
		BOOL	legacy,
		ICLRRuntimeInfo **	result
	)

Definition at line 1247 of file metahost.c.

{
    static const WCHAR dotconfig[] = {'.','c','o','n','f','i','g',0};
    static const DWORD supported_startup_flags = 0;
    static const DWORD supported_runtime_flags = RUNTIME_INFO_UPGRADE_VERSION;
    int i;
    WCHAR local_version[MAX_PATH];
    ULONG local_version_size = MAX_PATH;
    WCHAR local_config_file[MAX_PATH];
    HRESULT hr;
    parsed_config_file parsed_config;
 
    if (startup_flags & ~supported_startup_flags)
        FIXME("unsupported startup flags %x\n", startup_flags & ~supported_startup_flags);
 
    if (runtimeinfo_flags & ~supported_runtime_flags)
        FIXME("unsupported runtimeinfo flags %x\n", runtimeinfo_flags & ~supported_runtime_flags);
 
    if (exefile && !config_file)
    {
        strcpyW(local_config_file, exefile);
        strcatW(local_config_file, dotconfig);
 
        config_file = local_config_file;
    }
 
    if (config_file)
    {
        int found=0;
        hr = parse_config_file(config_file, &parsed_config);
 
        if (SUCCEEDED(hr))
        {
            supported_runtime *entry;
            LIST_FOR_EACH_ENTRY(entry, &parsed_config.supported_runtimes, supported_runtime, entry)
            {
                hr = CLRMetaHost_GetRuntime(0, entry->version, &IID_ICLRRuntimeInfo, (void**)result);
                if (SUCCEEDED(hr))
                {
                    found = 1;
                    break;
                }
            }
        }
        else
        {
            WARN("failed to parse config file %s, hr=%x\n", debugstr_w(config_file), hr);
        }
 
        free_parsed_config_file(&parsed_config);
 
        if (found)
            return S_OK;
    }
 
    if (exefile && !version)
    {
        hr = CLRMetaHost_GetVersionFromFile(0, exefile, local_version, &local_version_size);
 
        version = local_version;
 
        if (FAILED(hr)) return hr;
    }
 
    if (version)
    {
        hr = CLRMetaHost_GetRuntime(0, version, &IID_ICLRRuntimeInfo, (void**)result);
        if(SUCCEEDED(hr))
            return hr;
    }
 
    if (runtimeinfo_flags & RUNTIME_INFO_UPGRADE_VERSION)
    {
        DWORD major, minor, build;
 
        if (version && !parse_runtime_version(version, &major, &minor, &build))
        {
            ERR("Cannot parse %s\n", debugstr_w(version));
            return CLR_E_SHIM_RUNTIME;
        }
 
        find_runtimes();
 
        if (legacy)
            i = 2;
        else
            i = NUM_RUNTIMES;
 
        while (i--)
        {
            if (runtimes[i].mono_abi_version)
            {
                /* Must be greater or equal to the version passed in. */
                if (!version || ((runtimes[i].major >= major && runtimes[i].minor >= minor && runtimes[i].build >= build) ||
                     (runtimes[i].major >= major && runtimes[i].minor > minor) ||
                     (runtimes[i].major > major)))
                {
                    return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface,
                            &IID_ICLRRuntimeInfo, (void **)result);
                }
            }
        }
 
        if (legacy)
            missing_runtime_message(&runtimes[1]);
        else
            missing_runtime_message(&runtimes[NUM_RUNTIMES-1]);
 
        return CLR_E_SHIM_RUNTIME;
    }
 
    return CLR_E_SHIM_RUNTIME;
}

Referenced by _CorExeMain(), ClrCreateManagedInstance(), CorBindToRuntimeEx(), CorBindToRuntimeHost(), create_monodata(), GetCORSystemDirectory(), GetCORVersion(), GetRequestedRuntimeInfo(), and ReallyFixupVTable().

ICLRRuntimeInfo_GetRuntimeHost()

HRESULT ICLRRuntimeInfo_GetRuntimeHost	(	ICLRRuntimeInfo *	iface,
		RuntimeHost **	result
	)

Definition at line 544 of file metahost.c.

{
    struct CLRRuntimeInfo *This = impl_from_ICLRRuntimeInfo(iface);
 
    assert(This->ICLRRuntimeInfo_iface.lpVtbl == &CLRRuntimeInfoVtbl);
 
    return CLRRuntimeInfo_GetRuntimeHost(This, result);
}

Referenced by _CorExeMain(), ClrCreateManagedInstance(), create_monodata(), and ReallyFixupVTable().

MetaDataDispenser_CreateInstance()

HRESULT MetaDataDispenser_CreateInstance

(

IUnknown **

ppUnk

)

Definition at line 169 of file metadata.c.

{
    MetaDataDispenser *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(MetaDataDispenser));
 
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IMetaDataDispenserEx_iface.lpVtbl = &MetaDataDispenserVtbl;
    This->ref = 1;
 
    *ppUnk = (IUnknown*)This;
 
    return S_OK;
}

Referenced by RuntimeHost_GetInterface().

parse_config_file()

HRESULT parse_config_file	(	LPCWSTR	filename,
		parsed_config_file *	result
	)

Definition at line 419 of file config.c.

{
    IStream *stream;
    VARIANT var;
    HRESULT hr;
    HRESULT initresult;
 
    init_config(result);
 
    initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    hr = SHCreateStreamOnFileW(filename, STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE, &stream);
 
    if (SUCCEEDED(hr))
    {
        V_VT(&var) = VT_UNKNOWN;
        V_UNKNOWN(&var) = (IUnknown*)stream;
 
        hr = parse_config(var, result);
 
        IStream_Release(stream);
    }
 
    if (SUCCEEDED(initresult))
        CoUninitialize();
 
    return hr;
}

Referenced by get_runtime_info().

RuntimeHost_Construct()

HRESULT RuntimeHost_Construct	(	const CLRRuntimeInfo *	runtime_version,
		loaded_mono *	loaded_mono,
		RuntimeHost **	result
	)

Definition at line 1120 of file corruntimehost.c.

{
    RuntimeHost *This;
 
    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
    if ( !This )
        return E_OUTOFMEMORY;
 
    This->ICorRuntimeHost_iface.lpVtbl = &corruntimehost_vtbl;
    This->ICLRRuntimeHost_iface.lpVtbl = &CLRHostVtbl;
 
    This->ref = 1;
    This->version = runtime_version;
    This->mono = loaded_mono;
    list_init(&This->domains);
    This->default_domain = NULL;
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RuntimeHost.lock");
 
    *result = This;
 
    return S_OK;
}

Referenced by CLRRuntimeInfo_GetRuntimeHost().

RuntimeHost_CreateManagedInstance()

HRESULT RuntimeHost_CreateManagedInstance	(	RuntimeHost *	This,
		LPCWSTR	name,
		MonoDomain *	domain,
		MonoObject **	result
	)

Definition at line 638 of file corruntimehost.c.

{
    HRESULT hr=S_OK;
    char *nameA=NULL;
    MonoType *type;
    MonoClass *klass;
    MonoObject *obj;
 
    if (!domain)
        hr = RuntimeHost_GetDefaultDomain(This, &domain);
 
    if (SUCCEEDED(hr))
    {
        nameA = WtoA(name);
        if (!nameA)
            hr = E_OUTOFMEMORY;
    }
 
    if (SUCCEEDED(hr))
    {
        This->mono->mono_thread_attach(domain);
 
        type = This->mono->mono_reflection_type_from_name(nameA, NULL);
        if (!type)
        {
            ERR("Cannot find type %s\n", debugstr_w(name));
            hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
    {
        klass = This->mono->mono_class_from_mono_type(type);
        if (!klass)
        {
            ERR("Cannot convert type %s to a class\n", debugstr_w(name));
            hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
    {
        obj = This->mono->mono_object_new(domain, klass);
        if (!obj)
        {
            ERR("Cannot allocate object of type %s\n", debugstr_w(name));
            hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
    {
        /* FIXME: Detect exceptions from the constructor? */
        This->mono->mono_runtime_object_init(obj);
        *result = obj;
    }
 
    HeapFree(GetProcessHeap(), 0, nameA);
 
    return hr;
}

Referenced by ClrCreateManagedInstance().

RuntimeHost_Destroy()

HRESULT RuntimeHost_Destroy

(

RuntimeHost *

This

)

Definition at line 1190 of file corruntimehost.c.

{
    struct DomainEntry *cursor, *cursor2;
 
    This->lock.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&This->lock);
 
    LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &This->domains, struct DomainEntry, entry)
    {
        list_remove(&cursor->entry);
        HeapFree(GetProcessHeap(), 0, cursor);
    }
 
    HeapFree( GetProcessHeap(), 0, This );
    return S_OK;
}

Referenced by unload_all_runtimes().

RuntimeHost_GetInterface()

HRESULT RuntimeHost_GetInterface	(	RuntimeHost *	This,
		REFCLSID	clsid,
		REFIID	riid,
		void **	ppv
	)

Definition at line 1145 of file corruntimehost.c.

{
    IUnknown *unk;
    HRESULT hr;
 
    if (IsEqualGUID(clsid, &CLSID_CorRuntimeHost))
    {
        unk = (IUnknown*)&This->ICorRuntimeHost_iface;
        IUnknown_AddRef(unk);
    }
    else if (IsEqualGUID(clsid, &CLSID_CLRRuntimeHost))
    {
        unk = (IUnknown*)&This->ICLRRuntimeHost_iface;
        IUnknown_AddRef(unk);
    }
    else if (IsEqualGUID(clsid, &CLSID_CorMetaDataDispenser) ||
             IsEqualGUID(clsid, &CLSID_CorMetaDataDispenserRuntime))
    {
        hr = MetaDataDispenser_CreateInstance(&unk);
        if (FAILED(hr))
            return hr;
    }
    else if (IsEqualGUID(clsid, &CLSID_CLRDebuggingLegacy))
    {
        hr = CorDebug_Create(&This->ICLRRuntimeHost_iface, &unk);
        if (FAILED(hr))
            return hr;
    }
    else
        unk = NULL;
 
    if (unk)
    {
        hr = IUnknown_QueryInterface(unk, riid, ppv);
 
        IUnknown_Release(unk);
 
        return hr;
    }
    else
        FIXME("not implemented for class %s\n", debugstr_guid(clsid));
 
    return CLASS_E_CLASSNOTAVAILABLE;
}

Referenced by CLRRuntimeInfo_GetInterface().

RuntimeHost_GetIUnknownForObject()

HRESULT RuntimeHost_GetIUnknownForObject	(	RuntimeHost *	This,
		MonoObject *	obj,
		IUnknown **	ppUnk
	)

Definition at line 711 of file corruntimehost.c.

{
    MonoDomain *domain;
    MonoAssembly *assembly;
    MonoImage *image;
    MonoClass *klass;
    MonoMethod *method;
    MonoObject *result;
    void *args[2];
 
    domain = This->mono->mono_object_get_domain(obj);
 
    assembly = This->mono->mono_domain_assembly_open(domain, "mscorlib");
    if (!assembly)
    {
        ERR("Cannot load mscorlib\n");
        return E_FAIL;
    }
 
    image = This->mono->mono_assembly_get_image(assembly);
    if (!image)
    {
        ERR("Couldn't get assembly image\n");
        return E_FAIL;
    }
 
    klass = This->mono->mono_class_from_name(image, "System.Runtime.InteropServices", "Marshal");
    if (!klass)
    {
        ERR("Couldn't get class from image\n");
        return E_FAIL;
    }
 
    method = This->mono->mono_class_get_method_from_name(klass, "GetIUnknownForObject", 1);
    if (!method)
    {
        ERR("Couldn't get method from class\n");
        return E_FAIL;
    }
 
    args[0] = obj;
    args[1] = NULL;
    result = This->mono->mono_runtime_invoke(method, NULL, args, NULL);
    if (!result)
    {
        ERR("Couldn't get result pointer\n");
        return E_FAIL;
    }
 
    *ppUnk = *(IUnknown**)This->mono->mono_object_unbox(result);
    if (!*ppUnk)
    {
        ERR("GetIUnknownForObject returned 0\n");
        return E_FAIL;
    }
 
    return S_OK;
}

Referenced by ClrCreateManagedInstance(), create_monodata(), and RuntimeHost_GetIUnknownForDomain().

runtimehost_init()

void runtimehost_init

(

void

)

Definition at line 1101 of file corruntimehost.c.

{
    dll_fixup_heap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);
    list_init(&dll_fixups);
}

Referenced by DllMain().

runtimehost_uninit()

void runtimehost_uninit

(

void

)

Definition at line 1108 of file corruntimehost.c.

{
    struct dll_fixup *fixup, *fixup2;
 
    HeapDestroy(dll_fixup_heap);
    LIST_FOR_EACH_ENTRY_SAFE(fixup, fixup2, &dll_fixups, struct dll_fixup, entry)
    {
        HeapFree(GetProcessHeap(), 0, fixup->tokens);
        HeapFree(GetProcessHeap(), 0, fixup);
    }
}

Referenced by DllMain().

unload_all_runtimes()

void unload_all_runtimes

(

void

)

Definition at line 266 of file metahost.c.

{
    int i;
 
    for (i=0; i<NUM_ABI_VERSIONS; i++)
    {
        loaded_mono *mono = &loaded_monos[i];
        if (mono->mono_handle && mono->is_started && !mono->is_shutdown)
        {
            /* Copied from Mono's ves_icall_System_Environment_Exit */
        mono->mono_threads_set_shutting_down();
        mono->mono_runtime_set_shutting_down();
        mono->mono_thread_pool_cleanup();
        mono->mono_thread_suspend_all_other_threads();
        mono->mono_runtime_quit();
        }
    }
 
    for (i=0; i<NUM_RUNTIMES; i++)
        if (runtimes[i].loaded_runtime)
            RuntimeHost_Destroy(runtimes[i].loaded_runtime);
}

Referenced by _CorExeMain(), and CorExitProcess().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mscoree

)

WtoA()

char * WtoA

(

LPCWSTR

wstr

)

Definition at line 30 of file mscoree_main.c.

{
    int length;
    char *result;
 
    length = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
 
    result = HeapAlloc(GetProcessHeap(), 0, length);
 
    if (result)
        WideCharToMultiByte(CP_UTF8, 0, wstr, -1, result, length, NULL, NULL);
 
    return result;
}

Referenced by _CorExeMain(), CLRRuntimeHost_ExecuteInDefaultAppDomain(), create_monodata(), mono_assembly_search_hook_fn(), ReallyFixupVTable(), RuntimeHost_AddDomain(), and RuntimeHost_CreateManagedInstance().