dlls/mscoree/corruntimehost.c

   1 /*
   2  *
   3  * Copyright 2008 Alistair Leslie-Hughes
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "winnls.h"
  29 #include "winreg.h"
  30 #include "ole2.h"
  31 #include "shellapi.h"
  32
  33 #include "cor.h"
  34 #include "mscoree.h"
  35 #include "metahost.h"
  36 #include "corhdr.h"
  37 #include "cordebug.h"
  38 #include "wine/list.h"
  39 #include "mscoree_private.h"
  40
  41 #include "wine/debug.h"
  42 #include "wine/unicode.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL( mscoree );
  45
  46 #include "initguid.h"
  47
  48 DEFINE_GUID(IID__AppDomain, 0x05f696dc,0x2b29,0x3663,0xad,0x8b,0xc4,0x38,0x9c,0xf2,0xa7,0x13);
  49
  50 struct DomainEntry
  51 {
  52     struct list entry;
  53     MonoDomain *domain;
  54 };
  55
  56 static HANDLE dll_fixup_heap; /* using a separate heap so we can have execute permission */
  57
  58 static struct list dll_fixups;
  59
  60 struct dll_fixup
  61 {
  62     struct list entry;
  63     BOOL done;
  64     HMODULE dll;
  65     void *thunk_code; /* pointer into dll_fixup_heap */
  66     VTableFixup *fixup;
  67     void *vtable;
  68     void *tokens; /* pointer into process heap */
  69 };
  70
  71 static HRESULT RuntimeHost_AddDefaultDomain(RuntimeHost *This, MonoDomain **result)
  72 {
  73     struct DomainEntry *entry;
  74     HRESULT res=S_OK;
  75
  76     EnterCriticalSection(&This->lock);
  77
  78     entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
  79     if (!entry)
  80     {
  81         res = E_OUTOFMEMORY;
  82         goto end;
  83     }
  84
  85     /* FIXME: Use exe filename to name the domain? */
  86     entry->domain = mono_jit_init_version("mscorlib.dll", "v4.0.30319");
  87
  88     if (!entry->domain)
  89     {
  90         HeapFree(GetProcessHeap(), 0, entry);
  91         res = E_FAIL;
  92         goto end;
  93     }
  94
  95     is_mono_started = TRUE;
  96
  97     list_add_tail(&This->domains, &entry->entry);
  98
  99     *result = entry->domain;
 100
 101 end:
 102     LeaveCriticalSection(&This->lock);
 103
 104     return res;
 105 }
 106
 107 static HRESULT RuntimeHost_GetDefaultDomain(RuntimeHost *This, const WCHAR *config_path, MonoDomain **result)
 108 {
 109     WCHAR config_dir[MAX_PATH];
 110     WCHAR base_dir[MAX_PATH];
 111     char *base_dirA, *config_pathA, *slash;
 112     HRESULT res=S_OK;
 113
 114     EnterCriticalSection(&This->lock);
 115
 116     if (This->default_domain) goto end;
 117
 118     res = RuntimeHost_AddDefaultDomain(This, &This->default_domain);
 119
 120     if (!config_path)
 121     {
 122         DWORD len = sizeof(config_dir)/sizeof(*config_dir);
 123
 124         static const WCHAR machine_configW[] = {'\\','C','O','N','F','I','G','\\','m','a','c','h','i','n','e','.','c','o','n','f','i','g',0};
 125
 126         res = ICLRRuntimeInfo_GetRuntimeDirectory(&This->version->ICLRRuntimeInfo_iface,
 127                 config_dir, &len);
 128         if (FAILED(res))
 129             goto end;
 130
 131         lstrcatW(config_dir, machine_configW);
 132
 133         config_path = config_dir;
 134     }
 135
 136     config_pathA = WtoA(config_path);
 137     if (!config_pathA)
 138     {
 139         res = E_OUTOFMEMORY;
 140         goto end;
 141     }
 142
 143     GetModuleFileNameW(NULL, base_dir, sizeof(base_dir) / sizeof(*base_dir));
 144     base_dirA = WtoA(base_dir);
 145     if (!base_dirA)
 146     {
 147         HeapFree(GetProcessHeap(), 0, config_pathA);
 148         res = E_OUTOFMEMORY;
 149         goto end;
 150     }
 151
 152     slash = strrchr(base_dirA, '\\');
 153     if (slash)
 154         *slash = 0;
 155
 156     TRACE("setting base_dir: %s, config_path: %s\n", base_dirA, config_pathA);
 157     mono_domain_set_config(This->default_domain, base_dirA, config_pathA);
 158
 159     HeapFree(GetProcessHeap(), 0, config_pathA);
 160     HeapFree(GetProcessHeap(), 0, base_dirA);
 161
 162 end:
 163     *result = This->default_domain;
 164
 165     LeaveCriticalSection(&This->lock);
 166
 167     return res;
 168 }
 169
 170 static void RuntimeHost_DeleteDomain(RuntimeHost *This, MonoDomain *domain)
 171 {
 172     struct DomainEntry *entry;
 173
 174     EnterCriticalSection(&This->lock);
 175
 176     LIST_FOR_EACH_ENTRY(entry, &This->domains, struct DomainEntry, entry)
 177     {
 178         if (entry->domain == domain)
 179         {
 180             list_remove(&entry->entry);
 181             if (This->default_domain == domain)
 182                 This->default_domain = NULL;
 183             HeapFree(GetProcessHeap(), 0, entry);
 184             break;
 185         }
 186     }
 187
 188     LeaveCriticalSection(&This->lock);
 189 }
 190
 191 static BOOL RuntimeHost_GetMethod(MonoDomain *domain, const char *assemblyname,
 192     const char *namespace, const char *typename, const char *methodname, int arg_count,
 193     MonoMethod **method)
 194 {
 195     MonoAssembly *assembly;
 196     MonoImage *image;
 197     MonoClass *klass;
 198
 199     assembly = mono_domain_assembly_open(domain, assemblyname);
 200     if (!assembly)
 201     {
 202         ERR("Cannot load assembly %s\n", assemblyname);
 203         return FALSE;
 204     }
 205
 206     image = mono_assembly_get_image(assembly);
 207     if (!image)
 208     {
 209         ERR("Couldn't get assembly image for %s\n", assemblyname);
 210         return FALSE;
 211     }
 212
 213     klass = mono_class_from_name(image, namespace, typename);
 214     if (!klass)
 215     {
 216         ERR("Couldn't get class %s.%s from image\n", namespace, typename);
 217         return FALSE;
 218     }
 219
 220     *method = mono_class_get_method_from_name(klass, methodname, arg_count);
 221     if (!*method)
 222     {
 223         ERR("Couldn't get method %s from class %s.%s\n", methodname, namespace, typename);
 224         return FALSE;
 225     }
 226
 227     return TRUE;
 228 }
 229
 230 static HRESULT RuntimeHost_Invoke(RuntimeHost *This, MonoDomain *domain,
 231     const char *assemblyname, const char *namespace, const char *typename, const char *methodname,
 232     MonoObject *obj, void **args, int arg_count, MonoObject **result);
 233
 234 static HRESULT RuntimeHost_DoInvoke(RuntimeHost *This, MonoDomain *domain,
 235     const char *methodname, MonoMethod *method, MonoObject *obj, void **args, MonoObject **result)
 236 {
 237     MonoObject *exc;
 238     static const char *get_hresult = "get_HResult";
 239
 240     *result = mono_runtime_invoke(method, obj, args, &exc);
 241     if (exc)
 242     {
 243         HRESULT hr;
 244         MonoObject *hr_object;
 245
 246         if (methodname != get_hresult)
 247         {
 248             /* Map the exception to an HRESULT. */
 249             hr = RuntimeHost_Invoke(This, domain, "mscorlib", "System", "Exception", get_hresult,
 250                 exc, NULL, 0, &hr_object);
 251             if (SUCCEEDED(hr))
 252                 hr = *(HRESULT*)mono_object_unbox(hr_object);
 253             if (SUCCEEDED(hr))
 254                 hr = E_FAIL;
 255         }
 256         else
 257             hr = E_FAIL;
 258         *result = NULL;
 259         return hr;
 260     }
 261
 262     return S_OK;
 263 }
 264
 265 static HRESULT RuntimeHost_Invoke(RuntimeHost *This, MonoDomain *domain,
 266     const char *assemblyname, const char *namespace, const char *typename, const char *methodname,
 267     MonoObject *obj, void **args, int arg_count, MonoObject **result)
 268 {
 269     MonoMethod *method;
 270     HRESULT hr;
 271
 272     *result = NULL;
 273
 274     mono_thread_attach(domain);
 275
 276     if (!RuntimeHost_GetMethod(domain, assemblyname, namespace, typename, methodname,
 277             arg_count, &method))
 278     {
 279         return E_FAIL;
 280     }
 281
 282     hr = RuntimeHost_DoInvoke(This, domain, methodname, method, obj, args, result);
 283     if (FAILED(hr))
 284     {
 285         ERR("Method %s.%s:%s raised an exception, hr=%x\n", namespace, typename, methodname, hr);
 286     }
 287
 288     return hr;
 289 }
 290
 291 static HRESULT RuntimeHost_VirtualInvoke(RuntimeHost *This, MonoDomain *domain,
 292     const char *assemblyname, const char *namespace, const char *typename, const char *methodname,
 293     MonoObject *obj, void **args, int arg_count, MonoObject **result)
 294 {
 295     MonoMethod *method;
 296     HRESULT hr;
 297
 298     *result = NULL;
 299
 300     if (!obj)
 301     {
 302         ERR("\"this\" object cannot be null\n");
 303         return E_POINTER;
 304     }
 305
 306     mono_thread_attach(domain);
 307
 308     if (!RuntimeHost_GetMethod(domain, assemblyname, namespace, typename, methodname,
 309             arg_count, &method))
 310     {
 311         return E_FAIL;
 312     }
 313
 314     method = mono_object_get_virtual_method(obj, method);
 315     if (!method)
 316     {
 317         ERR("Object %p does not support method %s.%s:%s\n", obj, namespace, typename, methodname);
 318         return E_FAIL;
 319     }
 320
 321     hr = RuntimeHost_DoInvoke(This, domain, methodname, method, obj, args, result);
 322     if (FAILED(hr))
 323     {
 324         ERR("Method %s.%s:%s raised an exception, hr=%x\n", namespace, typename, methodname, hr);
 325     }
 326
 327     return hr;
 328 }
 329
 330 static HRESULT RuntimeHost_GetObjectForIUnknown(RuntimeHost *This, MonoDomain *domain,
 331     IUnknown *unk, MonoObject **obj)
 332 {
 333     HRESULT hr;
 334     void *args[1];
 335     MonoObject *result;
 336
 337     args[0] = &unk;
 338     hr = RuntimeHost_Invoke(This, domain, "mscorlib", "System.Runtime.InteropServices", "Marshal", "GetObjectForIUnknown",
 339         NULL, args, 1, &result);
 340
 341     if (SUCCEEDED(hr))
 342     {
 343         *obj = result;
 344     }
 345     return hr;
 346 }
 347
 348 static HRESULT RuntimeHost_AddDomain(RuntimeHost *This, const WCHAR *name, IUnknown *setup,
 349     IUnknown *evidence, MonoDomain **result)
 350 {
 351     HRESULT res;
 352     char *nameA;
 353     MonoDomain *domain;
 354     void *args[3];
 355     MonoObject *new_domain, *id;
 356
 357     res = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 358     if (FAILED(res))
 359     {
 360         return res;
 361     }
 362
 363     nameA = WtoA(name);
 364     if (!nameA)
 365     {
 366         return E_OUTOFMEMORY;
 367     }
 368
 369     args[0] = mono_string_new(domain, nameA);
 370     HeapFree(GetProcessHeap(), 0, nameA);
 371
 372     if (!args[0])
 373     {
 374         return E_OUTOFMEMORY;
 375     }
 376
 377     if (evidence)
 378     {
 379         res = RuntimeHost_GetObjectForIUnknown(This, domain, evidence, (MonoObject **)&args[1]);
 380         if (FAILED(res))
 381         {
 382             return res;
 383         }
 384     }
 385     else
 386     {
 387         args[1] = NULL;
 388     }
 389
 390     if (setup)
 391     {
 392         res = RuntimeHost_GetObjectForIUnknown(This, domain, setup, (MonoObject **)&args[2]);
 393         if (FAILED(res))
 394         {
 395             return res;
 396         }
 397     }
 398     else
 399     {
 400         args[2] = NULL;
 401     }
 402
 403     res = RuntimeHost_Invoke(This, domain, "mscorlib", "System", "AppDomain", "CreateDomain",
 404         NULL, args, 3, &new_domain);
 405
 406     if (FAILED(res))
 407     {
 408         return res;
 409     }
 410
 411     /* new_domain is not the AppDomain itself, but a transparent proxy.
 412      * So, we'll retrieve its ID, and use that to get the real domain object.
 413      * We can't do a regular invoke, because that will bypass the proxy.
 414      * Instead, do a vcall.
 415      */
 416
 417     res = RuntimeHost_VirtualInvoke(This, domain, "mscorlib", "System", "AppDomain", "get_Id",
 418         new_domain, NULL, 0, &id);
 419
 420     if (FAILED(res))
 421     {
 422         return res;
 423     }
 424
 425     TRACE("returning domain id %d\n", *(int *)mono_object_unbox(id));
 426
 427     *result = mono_domain_get_by_id(*(int *)mono_object_unbox(id));
 428
 429     return S_OK;
 430 }
 431
 432 static HRESULT RuntimeHost_GetIUnknownForDomain(RuntimeHost *This, MonoDomain *domain, IUnknown **punk)
 433 {
 434     HRESULT hr;
 435     MonoObject *appdomain_object;
 436     IUnknown *unk;
 437
 438     hr = RuntimeHost_Invoke(This, domain, "mscorlib", "System", "AppDomain", "get_CurrentDomain",
 439         NULL, NULL, 0, &appdomain_object);
 440
 441     if (SUCCEEDED(hr))
 442         hr = RuntimeHost_GetIUnknownForObject(This, appdomain_object, &unk);
 443
 444     if (SUCCEEDED(hr))
 445     {
 446         hr = IUnknown_QueryInterface(unk, &IID__AppDomain, (void**)punk);
 447
 448         IUnknown_Release(unk);
 449     }
 450
 451     return hr;
 452 }
 453
 454 void RuntimeHost_ExitProcess(RuntimeHost *This, INT exitcode)
 455 {
 456     HRESULT hr;
 457     void *args[2];
 458     MonoDomain *domain;
 459     MonoObject *dummy;
 460
 461     hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 462     if (FAILED(hr))
 463     {
 464         ERR("Cannot get domain, hr=%x\n", hr);
 465         return;
 466     }
 467
 468     args[0] = &exitcode;
 469     args[1] = NULL;
 470     RuntimeHost_Invoke(This, domain, "mscorlib", "System", "Environment", "Exit",
 471         NULL, args, 1, &dummy);
 472
 473     ERR("Process should have exited\n");
 474 }
 475
 476 static inline RuntimeHost *impl_from_ICLRRuntimeHost( ICLRRuntimeHost *iface )
 477 {
 478     return CONTAINING_RECORD(iface, RuntimeHost, ICLRRuntimeHost_iface);
 479 }
 480
 481 static inline RuntimeHost *impl_from_ICorRuntimeHost( ICorRuntimeHost *iface )
 482 {
 483     return CONTAINING_RECORD(iface, RuntimeHost, ICorRuntimeHost_iface);
 484 }
 485
 486 /*** IUnknown methods ***/
 487 static HRESULT WINAPI corruntimehost_QueryInterface(ICorRuntimeHost* iface,
 488         REFIID riid,
 489         void **ppvObject)
 490 {
 491     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 492     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 493
 494     if ( IsEqualGUID( riid, &IID_ICorRuntimeHost ) ||
 495          IsEqualGUID( riid, &IID_IUnknown ) )
 496     {
 497         *ppvObject = iface;
 498     }
 499     else
 500     {
 501         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 502         return E_NOINTERFACE;
 503     }
 504
 505     ICorRuntimeHost_AddRef( iface );
 506
 507     return S_OK;
 508 }
 509
 510 static ULONG WINAPI corruntimehost_AddRef(ICorRuntimeHost* iface)
 511 {
 512     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 513
 514     return InterlockedIncrement( &This->ref );
 515 }
 516
 517 static ULONG WINAPI corruntimehost_Release(ICorRuntimeHost* iface)
 518 {
 519     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 520     ULONG ref;
 521
 522     ref = InterlockedDecrement( &This->ref );
 523
 524     return ref;
 525 }
 526
 527 /*** ICorRuntimeHost methods ***/
 528 static HRESULT WINAPI corruntimehost_CreateLogicalThreadState(
 529                     ICorRuntimeHost* iface)
 530 {
 531     FIXME("stub %p\n", iface);
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI corruntimehost_DeleteLogicalThreadState(
 536                     ICorRuntimeHost* iface)
 537 {
 538     FIXME("stub %p\n", iface);
 539     return E_NOTIMPL;
 540 }
 541
 542 static HRESULT WINAPI corruntimehost_SwitchInLogicalThreadState(
 543                     ICorRuntimeHost* iface,
 544                     DWORD *fiberCookie)
 545 {
 546     FIXME("stub %p\n", iface);
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI corruntimehost_SwitchOutLogicalThreadState(
 551                     ICorRuntimeHost* iface,
 552                     DWORD **fiberCookie)
 553 {
 554     FIXME("stub %p\n", iface);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI corruntimehost_LocksHeldByLogicalThread(
 559                     ICorRuntimeHost* iface,
 560                     DWORD *pCount)
 561 {
 562     FIXME("stub %p\n", iface);
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI corruntimehost_MapFile(
 567     ICorRuntimeHost* iface,
 568     HANDLE hFile,
 569     HMODULE *mapAddress)
 570 {
 571     FIXME("stub %p\n", iface);
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI corruntimehost_GetConfiguration(
 576     ICorRuntimeHost* iface,
 577     ICorConfiguration **pConfiguration)
 578 {
 579     FIXME("stub %p\n", iface);
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI corruntimehost_Start(
 584     ICorRuntimeHost* iface)
 585 {
 586     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 587     MonoDomain *dummy;
 588
 589     TRACE("%p\n", This);
 590
 591     return RuntimeHost_GetDefaultDomain(This, NULL, &dummy);
 592 }
 593
 594 static HRESULT WINAPI corruntimehost_Stop(
 595     ICorRuntimeHost* iface)
 596 {
 597     FIXME("stub %p\n", iface);
 598     return E_NOTIMPL;
 599 }
 600
 601 static HRESULT WINAPI corruntimehost_CreateDomain(
 602     ICorRuntimeHost* iface,
 603     LPCWSTR friendlyName,
 604     IUnknown *identityArray,
 605     IUnknown **appDomain)
 606 {
 607     return ICorRuntimeHost_CreateDomainEx(iface, friendlyName, NULL, NULL, appDomain);
 608 }
 609
 610 static HRESULT WINAPI corruntimehost_GetDefaultDomain(
 611     ICorRuntimeHost* iface,
 612     IUnknown **pAppDomain)
 613 {
 614     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 615     HRESULT hr;
 616     MonoDomain *domain;
 617
 618     TRACE("(%p)\n", iface);
 619
 620     hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 621
 622     if (SUCCEEDED(hr))
 623     {
 624         hr = RuntimeHost_GetIUnknownForDomain(This, domain, pAppDomain);
 625     }
 626
 627     return hr;
 628 }
 629
 630 static HRESULT WINAPI corruntimehost_EnumDomains(
 631     ICorRuntimeHost* iface,
 632     HDOMAINENUM *hEnum)
 633 {
 634     FIXME("stub %p\n", iface);
 635     return E_NOTIMPL;
 636 }
 637
 638 static HRESULT WINAPI corruntimehost_NextDomain(
 639     ICorRuntimeHost* iface,
 640     HDOMAINENUM hEnum,
 641     IUnknown **appDomain)
 642 {
 643     FIXME("stub %p\n", iface);
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI corruntimehost_CloseEnum(
 648     ICorRuntimeHost* iface,
 649     HDOMAINENUM hEnum)
 650 {
 651     FIXME("stub %p\n", iface);
 652     return E_NOTIMPL;
 653 }
 654
 655 static HRESULT WINAPI corruntimehost_CreateDomainEx(
 656     ICorRuntimeHost* iface,
 657     LPCWSTR friendlyName,
 658     IUnknown *setup,
 659     IUnknown *evidence,
 660     IUnknown **appDomain)
 661 {
 662     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 663     HRESULT hr;
 664     MonoDomain *domain;
 665
 666     if (!friendlyName || !appDomain)
 667     {
 668         return E_POINTER;
 669     }
 670     if (!is_mono_started)
 671     {
 672         return E_FAIL;
 673     }
 674
 675     TRACE("(%p)\n", iface);
 676
 677     hr = RuntimeHost_AddDomain(This, friendlyName, setup, evidence, &domain);
 678
 679     if (SUCCEEDED(hr))
 680     {
 681         hr = RuntimeHost_GetIUnknownForDomain(This, domain, appDomain);
 682     }
 683
 684     return hr;
 685 }
 686
 687 static HRESULT WINAPI corruntimehost_CreateDomainSetup(
 688     ICorRuntimeHost* iface,
 689     IUnknown **appDomainSetup)
 690 {
 691     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 692     HRESULT hr;
 693     MonoDomain *domain;
 694     MonoObject *obj;
 695     static const WCHAR classnameW[] = {'S','y','s','t','e','m','.','A','p','p','D','o','m','a','i','n','S','e','t','u','p',',','m','s','c','o','r','l','i','b',0};
 696
 697     TRACE("(%p)\n", iface);
 698
 699     hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 700
 701     if (SUCCEEDED(hr))
 702         hr = RuntimeHost_CreateManagedInstance(This, classnameW, domain, &obj);
 703
 704     if (SUCCEEDED(hr))
 705         hr = RuntimeHost_GetIUnknownForObject(This, obj, appDomainSetup);
 706
 707     return hr;
 708 }
 709
 710 static HRESULT WINAPI corruntimehost_CreateEvidence(
 711     ICorRuntimeHost* iface,
 712     IUnknown **evidence)
 713 {
 714     FIXME("stub %p\n", iface);
 715     return E_NOTIMPL;
 716 }
 717
 718 static HRESULT WINAPI corruntimehost_UnloadDomain(
 719     ICorRuntimeHost* iface,
 720     IUnknown *appDomain)
 721 {
 722     FIXME("stub %p\n", iface);
 723     return E_NOTIMPL;
 724 }
 725
 726 static HRESULT WINAPI corruntimehost_CurrentDomain(
 727     ICorRuntimeHost* iface,
 728     IUnknown **appDomain)
 729 {
 730     FIXME("stub %p\n", iface);
 731     return E_NOTIMPL;
 732 }
 733
 734 static const struct ICorRuntimeHostVtbl corruntimehost_vtbl =
 735 {
 736     corruntimehost_QueryInterface,
 737     corruntimehost_AddRef,
 738     corruntimehost_Release,
 739     corruntimehost_CreateLogicalThreadState,
 740     corruntimehost_DeleteLogicalThreadState,
 741     corruntimehost_SwitchInLogicalThreadState,
 742     corruntimehost_SwitchOutLogicalThreadState,
 743     corruntimehost_LocksHeldByLogicalThread,
 744     corruntimehost_MapFile,
 745     corruntimehost_GetConfiguration,
 746     corruntimehost_Start,
 747     corruntimehost_Stop,
 748     corruntimehost_CreateDomain,
 749     corruntimehost_GetDefaultDomain,
 750     corruntimehost_EnumDomains,
 751     corruntimehost_NextDomain,
 752     corruntimehost_CloseEnum,
 753     corruntimehost_CreateDomainEx,
 754     corruntimehost_CreateDomainSetup,
 755     corruntimehost_CreateEvidence,
 756     corruntimehost_UnloadDomain,
 757     corruntimehost_CurrentDomain
 758 };
 759
 760 static HRESULT WINAPI CLRRuntimeHost_QueryInterface(ICLRRuntimeHost* iface,
 761         REFIID riid,
 762         void **ppvObject)
 763 {
 764     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 765     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 766
 767     if ( IsEqualGUID( riid, &IID_ICLRRuntimeHost ) ||
 768          IsEqualGUID( riid, &IID_IUnknown ) )
 769     {
 770         *ppvObject = iface;
 771     }
 772     else
 773     {
 774         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 775         return E_NOINTERFACE;
 776     }
 777
 778     ICLRRuntimeHost_AddRef( iface );
 779
 780     return S_OK;
 781 }
 782
 783 static ULONG WINAPI CLRRuntimeHost_AddRef(ICLRRuntimeHost* iface)
 784 {
 785     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 786     return ICorRuntimeHost_AddRef(&This->ICorRuntimeHost_iface);
 787 }
 788
 789 static ULONG WINAPI CLRRuntimeHost_Release(ICLRRuntimeHost* iface)
 790 {
 791     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 792     return ICorRuntimeHost_Release(&This->ICorRuntimeHost_iface);
 793 }
 794
 795 static HRESULT WINAPI CLRRuntimeHost_Start(ICLRRuntimeHost* iface)
 796 {
 797     FIXME("(%p)\n", iface);
 798     return E_NOTIMPL;
 799 }
 800
 801 static HRESULT WINAPI CLRRuntimeHost_Stop(ICLRRuntimeHost* iface)
 802 {
 803     FIXME("(%p)\n", iface);
 804     return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI CLRRuntimeHost_SetHostControl(ICLRRuntimeHost* iface,
 808     IHostControl *pHostControl)
 809 {
 810     FIXME("(%p,%p)\n", iface, pHostControl);
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI CLRRuntimeHost_GetCLRControl(ICLRRuntimeHost* iface,
 815     ICLRControl **pCLRControl)
 816 {
 817     FIXME("(%p,%p)\n", iface, pCLRControl);
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI CLRRuntimeHost_UnloadAppDomain(ICLRRuntimeHost* iface,
 822     DWORD dwAppDomainId, BOOL fWaitUntilDone)
 823 {
 824     FIXME("(%p,%u,%i)\n", iface, dwAppDomainId, fWaitUntilDone);
 825     return E_NOTIMPL;
 826 }
 827
 828 static HRESULT WINAPI CLRRuntimeHost_ExecuteInAppDomain(ICLRRuntimeHost* iface,
 829     DWORD dwAppDomainId, FExecuteInAppDomainCallback pCallback, void *cookie)
 830 {
 831     FIXME("(%p,%u,%p,%p)\n", iface, dwAppDomainId, pCallback, cookie);
 832     return E_NOTIMPL;
 833 }
 834
 835 static HRESULT WINAPI CLRRuntimeHost_GetCurrentAppDomainId(ICLRRuntimeHost* iface,
 836     DWORD *pdwAppDomainId)
 837 {
 838     FIXME("(%p,%p)\n", iface, pdwAppDomainId);
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI CLRRuntimeHost_ExecuteApplication(ICLRRuntimeHost* iface,
 843     LPCWSTR pwzAppFullName, DWORD dwManifestPaths, LPCWSTR *ppwzManifestPaths,
 844     DWORD dwActivationData, LPCWSTR *ppwzActivationData, int *pReturnValue)
 845 {
 846     FIXME("(%p,%s,%u,%u)\n", iface, debugstr_w(pwzAppFullName), dwManifestPaths, dwActivationData);
 847     return E_NOTIMPL;
 848 }
 849
 850 static HRESULT WINAPI CLRRuntimeHost_ExecuteInDefaultAppDomain(ICLRRuntimeHost* iface,
 851     LPCWSTR pwzAssemblyPath, LPCWSTR pwzTypeName, LPCWSTR pwzMethodName,
 852     LPCWSTR pwzArgument, DWORD *pReturnValue)
 853 {
 854     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 855     HRESULT hr;
 856     MonoDomain *domain;
 857     MonoObject *result;
 858     MonoString *str;
 859     char *filenameA = NULL, *classA = NULL, *methodA = NULL;
 860     char *argsA = NULL, *ns;
 861
 862     TRACE("(%p,%s,%s,%s,%s)\n", iface, debugstr_w(pwzAssemblyPath),
 863         debugstr_w(pwzTypeName), debugstr_w(pwzMethodName), debugstr_w(pwzArgument));
 864
 865     hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 866
 867     if (SUCCEEDED(hr))
 868     {
 869         mono_thread_attach(domain);
 870
 871         filenameA = WtoA(pwzAssemblyPath);
 872         if (!filenameA) hr = E_OUTOFMEMORY;
 873     }
 874
 875     if (SUCCEEDED(hr))
 876     {
 877         classA = WtoA(pwzTypeName);
 878         if (!classA) hr = E_OUTOFMEMORY;
 879     }
 880
 881     if (SUCCEEDED(hr))
 882     {
 883         ns = strrchr(classA, '.');
 884         if (ns)
 885             *ns = '\0';
 886         else
 887             hr = E_INVALIDARG;
 888     }
 889
 890     if (SUCCEEDED(hr))
 891     {
 892         methodA = WtoA(pwzMethodName);
 893         if (!methodA) hr = E_OUTOFMEMORY;
 894     }
 895
 896     /* The .NET function we are calling has the following declaration
 897      *   public static int functionName(String param)
 898      */
 899     if (SUCCEEDED(hr))
 900     {
 901         argsA = WtoA(pwzArgument);
 902         if (!argsA) hr = E_OUTOFMEMORY;
 903     }
 904
 905     if (SUCCEEDED(hr))
 906     {
 907         str = mono_string_new(domain, argsA);
 908         if (!str) hr = E_OUTOFMEMORY;
 909     }
 910
 911     if (SUCCEEDED(hr))
 912     {
 913         hr = RuntimeHost_Invoke(This, domain, filenameA, classA, ns+1, methodA,
 914             NULL, (void**)&str, 1, &result);
 915     }
 916
 917     if (SUCCEEDED(hr))
 918         *pReturnValue = *(DWORD*)mono_object_unbox(result);
 919
 920     HeapFree(GetProcessHeap(), 0, filenameA);
 921     HeapFree(GetProcessHeap(), 0, classA);
 922     HeapFree(GetProcessHeap(), 0, argsA);
 923     HeapFree(GetProcessHeap(), 0, methodA);
 924
 925     return hr;
 926 }
 927
 928 static const struct ICLRRuntimeHostVtbl CLRHostVtbl =
 929 {
 930     CLRRuntimeHost_QueryInterface,
 931     CLRRuntimeHost_AddRef,
 932     CLRRuntimeHost_Release,
 933     CLRRuntimeHost_Start,
 934     CLRRuntimeHost_Stop,
 935     CLRRuntimeHost_SetHostControl,
 936     CLRRuntimeHost_GetCLRControl,
 937     CLRRuntimeHost_UnloadAppDomain,
 938     CLRRuntimeHost_ExecuteInAppDomain,
 939     CLRRuntimeHost_GetCurrentAppDomainId,
 940     CLRRuntimeHost_ExecuteApplication,
 941     CLRRuntimeHost_ExecuteInDefaultAppDomain
 942 };
 943
 944 /* Create an instance of a type given its name, by calling its constructor with
 945  * no arguments. Note that result MUST be in the stack, or the garbage
 946  * collector may free it prematurely. */
 947 HRESULT RuntimeHost_CreateManagedInstance(RuntimeHost *This, LPCWSTR name,
 948     MonoDomain *domain, MonoObject **result)
 949 {
 950     HRESULT hr=S_OK;
 951     char *nameA=NULL;
 952     MonoType *type;
 953     MonoClass *klass;
 954     MonoObject *obj;
 955
 956     if (!domain)
 957         hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 958
 959     if (SUCCEEDED(hr))
 960     {
 961         nameA = WtoA(name);
 962         if (!nameA)
 963             hr = E_OUTOFMEMORY;
 964     }
 965
 966     if (SUCCEEDED(hr))
 967     {
 968         mono_thread_attach(domain);
 969
 970         type = mono_reflection_type_from_name(nameA, NULL);
 971         if (!type)
 972         {
 973             ERR("Cannot find type %s\n", debugstr_w(name));
 974             hr = E_FAIL;
 975         }
 976     }
 977
 978     if (SUCCEEDED(hr))
 979     {
 980         klass = mono_class_from_mono_type(type);
 981         if (!klass)
 982         {
 983             ERR("Cannot convert type %s to a class\n", debugstr_w(name));
 984             hr = E_FAIL;
 985         }
 986     }
 987
 988     if (SUCCEEDED(hr))
 989     {
 990         obj = mono_object_new(domain, klass);
 991         if (!obj)
 992         {
 993             ERR("Cannot allocate object of type %s\n", debugstr_w(name));
 994             hr = E_FAIL;
 995         }
 996     }
 997
 998     if (SUCCEEDED(hr))
 999     {
1000         /* FIXME: Detect exceptions from the constructor? */
1001         mono_runtime_object_init(obj);
1002         *result = obj;
1003     }
1004
1005     HeapFree(GetProcessHeap(), 0, nameA);
1006
1007     return hr;
1008 }
1009
1010 /* Get an IUnknown pointer for a Mono object.
1011  *
1012  * This is just a "light" wrapper around
1013  * System.Runtime.InteropServices.Marshal:GetIUnknownForObject
1014  *
1015  * NOTE: The IUnknown* is created with a reference to the object.
1016  * Until they have a reference, objects must be in the stack to prevent the
1017  * garbage collector from freeing them.
1018  *
1019  * mono_thread_attach must have already been called for this thread. */
1020 HRESULT RuntimeHost_GetIUnknownForObject(RuntimeHost *This, MonoObject *obj,
1021     IUnknown **ppUnk)
1022 {
1023     MonoDomain *domain;
1024     MonoObject *result;
1025     HRESULT hr;
1026
1027     domain = mono_object_get_domain(obj);
1028
1029     hr = RuntimeHost_Invoke(This, domain, "mscorlib", "System.Runtime.InteropServices", "Marshal", "GetIUnknownForObject",
1030         NULL, (void**)&obj, 1, &result);
1031
1032     if (SUCCEEDED(hr))
1033         *ppUnk = *(IUnknown**)mono_object_unbox(result);
1034     else
1035         *ppUnk = NULL;
1036
1037     return hr;
1038 }
1039
1040 static void get_utf8_args(int *argc, char ***argv)
1041 {
1042     WCHAR **argvw;
1043     int size=0, i;
1044     char *current_arg;
1045
1046     argvw = CommandLineToArgvW(GetCommandLineW(), argc);
1047
1048     for (i=0; i<*argc; i++)
1049     {
1050         size += sizeof(char*);
1051         size += WideCharToMultiByte(CP_UTF8, 0, argvw[i], -1, NULL, 0, NULL, NULL);
1052     }
1053     size += sizeof(char*);
1054
1055     *argv = HeapAlloc(GetProcessHeap(), 0, size);
1056     current_arg = (char*)(*argv + *argc + 1);
1057
1058     for (i=0; i<*argc; i++)
1059     {
1060         (*argv)[i] = current_arg;
1061         current_arg += WideCharToMultiByte(CP_UTF8, 0, argvw[i], -1, current_arg, size, NULL, NULL);
1062     }
1063
1064     (*argv)[*argc] = NULL;
1065
1066     HeapFree(GetProcessHeap(), 0, argvw);
1067 }
1068
1069 #if __i386__
1070
1071 # define CAN_FIXUP_VTABLE 1
1072
1073 #include "pshpack1.h"
1074
1075 struct vtable_fixup_thunk
1076 {
1077     /* push %ecx */
1078     BYTE i7;
1079     /* sub $0x4,%esp */
1080     BYTE i1[3];
1081     /* mov fixup,(%esp) */
1082     BYTE i2[3];
1083     struct dll_fixup *fixup;
1084     /* mov function,%eax */
1085     BYTE i3;
1086     void (CDECL *function)(struct dll_fixup *);
1087     /* call *%eax */
1088     BYTE i4[2];
1089     /* pop %eax */
1090     BYTE i5;
1091     /* pop %ecx */
1092     BYTE i8;
1093     /* jmp *vtable_entry */
1094     BYTE i6[2];
1095     void *vtable_entry;
1096 };
1097
1098 static const struct vtable_fixup_thunk thunk_template = {
1099     0x51,
1100     {0x83,0xec,0x04},
1101     {0xc7,0x04,0x24},
1102     NULL,
1103     0xb8,
1104     NULL,
1105     {0xff,0xd0},
1106     0x58,
1107     0x59,
1108     {0xff,0x25},
1109     NULL
1110 };
1111
1112 #include "poppack.h"
1113
1114 #elif __x86_64__ /* !__i386__ */
1115
1116 # define CAN_FIXUP_VTABLE 1
1117
1118 #include "pshpack1.h"
1119
1120 struct vtable_fixup_thunk
1121 {
1122     /* push %rbp;
1123        mov %rsp, %rbp
1124        sub $0x80, %rsp ; 0x8*4 + 0x10*4 + 0x20
1125     */
1126     BYTE i1[11];
1127     /*
1128         mov %rcx, 0x60(%rsp); mov %rdx, 0x68(%rsp); mov %r8, 0x70(%rsp); mov %r9, 0x78(%rsp);
1129         movaps %xmm0,0x20(%rsp); ...; movaps %xmm3,0x50(%esp)
1130     */
1131     BYTE i2[40];
1132     /* mov function,%rax */
1133     BYTE i3[2];
1134     void (CDECL *function)(struct dll_fixup *);
1135     /* mov fixup,%rcx */
1136     BYTE i4[2];
1137     struct dll_fixup *fixup;
1138     /* call *%rax */
1139     BYTE i5[2];
1140     /*
1141         mov 0x60(%rsp),%rcx; mov 0x68(%rsp),%rdx; mov 0x70(%rsp),%r8; mov 0x78(%rsp),%r9;
1142         movaps 0x20(%rsp),xmm0; ...; movaps 0x50(%esp),xmm3
1143     */
1144     BYTE i6[40];
1145     /* mov %rbp, %rsp
1146        pop %rbp
1147     */
1148     BYTE i7[4];
1149     /* mov vtable_entry, %rax */
1150     BYTE i8[2];
1151     void *vtable_entry;
1152     /* mov [%rax],%rax
1153        jmp %rax */
1154     BYTE i9[5];
1155 };
1156
1157 static const struct vtable_fixup_thunk thunk_template = {
1158     {0x55,0x48,0x89,0xE5,  0x48,0x81,0xEC,0x80,0x00,0x00,0x00},
1159     {0x48,0x89,0x4C,0x24,0x60, 0x48,0x89,0x54,0x24,0x68,
1160      0x4C,0x89,0x44,0x24,0x70, 0x4C,0x89,0x4C,0x24,0x78,
1161      0x0F,0x29,0x44,0x24,0x20, 0x0F,0x29,0x4C,0x24,0x30,
1162      0x0F,0x29,0x54,0x24,0x40, 0x0F,0x29,0x5C,0x24,0x50,
1163     },
1164     {0x48,0xB8},
1165     NULL,
1166     {0x48,0xB9},
1167     NULL,
1168     {0xFF,0xD0},
1169     {0x48,0x8B,0x4C,0x24,0x60, 0x48,0x8B,0x54,0x24,0x68,
1170      0x4C,0x8B,0x44,0x24,0x70, 0x4C,0x8B,0x4C,0x24,0x78,
1171      0x0F,0x28,0x44,0x24,0x20, 0x0F,0x28,0x4C,0x24,0x30,
1172      0x0F,0x28,0x54,0x24,0x40, 0x0F,0x28,0x5C,0x24,0x50,
1173      },
1174     {0x48,0x89,0xEC, 0x5D},
1175     {0x48,0xB8},
1176     NULL,
1177     {0x48,0x8B,0x00,0xFF,0xE0}
1178 };
1179
1180 #include "poppack.h"
1181
1182 #else /* !__i386__ && !__x86_64__ */
1183
1184 # define CAN_FIXUP_VTABLE 0
1185
1186 struct vtable_fixup_thunk
1187 {
1188     struct dll_fixup *fixup;
1189     void (CDECL *function)(struct dll_fixup *fixup);
1190     void *vtable_entry;
1191 };
1192
1193 static const struct vtable_fixup_thunk thunk_template = {0};
1194
1195 #endif
1196
1197 static void CDECL ReallyFixupVTable(struct dll_fixup *fixup)
1198 {
1199     HRESULT hr=S_OK;
1200     WCHAR filename[MAX_PATH];
1201     ICLRRuntimeInfo *info=NULL;
1202     RuntimeHost *host;
1203     char *filenameA;
1204     MonoImage *image=NULL;
1205     MonoAssembly *assembly=NULL;
1206     MonoImageOpenStatus status=0;
1207     MonoDomain *domain;
1208
1209     if (fixup->done) return;
1210
1211     /* It's possible we'll have two threads doing this at once. This is
1212      * considered preferable to the potential deadlock if we use a mutex. */
1213
1214     GetModuleFileNameW(fixup->dll, filename, MAX_PATH);
1215
1216     TRACE("%p,%p,%s\n", fixup, fixup->dll, debugstr_w(filename));
1217
1218     filenameA = WtoA(filename);
1219     if (!filenameA)
1220         hr = E_OUTOFMEMORY;
1221
1222     if (SUCCEEDED(hr))
1223         hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
1224
1225     if (SUCCEEDED(hr))
1226         hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
1227
1228     if (SUCCEEDED(hr))
1229         hr = RuntimeHost_GetDefaultDomain(host, NULL, &domain);
1230
1231     if (SUCCEEDED(hr))
1232     {
1233         mono_thread_attach(domain);
1234
1235         assembly = mono_assembly_open(filenameA, &status);
1236     }
1237
1238     if (assembly)
1239     {
1240         int i;
1241
1242         /* Mono needs an image that belongs to an assembly. */
1243         image = mono_assembly_get_image(assembly);
1244
1245 #if __x86_64__
1246         if (fixup->fixup->type & COR_VTABLE_64BIT)
1247 #else
1248         if (fixup->fixup->type & COR_VTABLE_32BIT)
1249 #endif
1250         {
1251             void **vtable = fixup->vtable;
1252             ULONG_PTR *tokens = fixup->tokens;
1253             for (i=0; i<fixup->fixup->count; i++)
1254             {
1255                 TRACE("%#lx\n", tokens[i]);
1256                 vtable[i] = mono_marshal_get_vtfixup_ftnptr(
1257                     image, tokens[i], fixup->fixup->type);
1258             }
1259         }
1260
1261         fixup->done = TRUE;
1262     }
1263
1264     if (info != NULL)
1265         ICLRRuntimeInfo_Release(info);
1266
1267     HeapFree(GetProcessHeap(), 0, filenameA);
1268
1269     if (!fixup->done)
1270     {
1271         ERR("unable to fixup vtable, hr=%x, status=%d\n", hr, status);
1272         /* If we returned now, we'd get an infinite loop. */
1273         assert(0);
1274     }
1275 }
1276
1277 static void FixupVTableEntry(HMODULE hmodule, VTableFixup *vtable_fixup)
1278 {
1279     /* We can't actually generate code for the functions without loading mono,
1280      * and loading mono inside DllMain is a terrible idea. So we make thunks
1281      * that call ReallyFixupVTable, which will load the runtime and fill in the
1282      * vtable, then do an indirect jump using the (now filled in) vtable. Note
1283      * that we have to keep the thunks around forever, as one of them may get
1284      * called while we're filling in the table, and we can never be sure all
1285      * threads are clear. */
1286     struct dll_fixup *fixup;
1287
1288     fixup = HeapAlloc(GetProcessHeap(), 0, sizeof(*fixup));
1289
1290     fixup->dll = hmodule;
1291     fixup->thunk_code = HeapAlloc(dll_fixup_heap, 0, sizeof(struct vtable_fixup_thunk) * vtable_fixup->count);
1292     fixup->fixup = vtable_fixup;
1293     fixup->vtable = (BYTE*)hmodule + vtable_fixup->rva;
1294     fixup->done = FALSE;
1295
1296     TRACE("vtable_fixup->type=0x%x\n",vtable_fixup->type);
1297 #if __x86_64__
1298     if (vtable_fixup->type & COR_VTABLE_64BIT)
1299 #else
1300     if (vtable_fixup->type & COR_VTABLE_32BIT)
1301 #endif
1302     {
1303         void **vtable = fixup->vtable;
1304         ULONG_PTR *tokens;
1305         int i;
1306         struct vtable_fixup_thunk *thunks = fixup->thunk_code;
1307
1308         tokens = fixup->tokens = HeapAlloc(GetProcessHeap(), 0, sizeof(*tokens) * vtable_fixup->count);
1309         memcpy(tokens, vtable, sizeof(*tokens) * vtable_fixup->count);
1310         for (i=0; i<vtable_fixup->count; i++)
1311         {
1312             thunks[i] = thunk_template;
1313             thunks[i].fixup = fixup;
1314             thunks[i].function = ReallyFixupVTable;
1315             thunks[i].vtable_entry = &vtable[i];
1316             vtable[i] = &thunks[i];
1317         }
1318     }
1319     else
1320     {
1321         ERR("unsupported vtable fixup flags %x\n", vtable_fixup->type);
1322         HeapFree(dll_fixup_heap, 0, fixup->thunk_code);
1323         HeapFree(GetProcessHeap(), 0, fixup);
1324         return;
1325     }
1326
1327     list_add_tail(&dll_fixups, &fixup->entry);
1328 }
1329
1330 static void FixupVTable_Assembly(HMODULE hmodule, ASSEMBLY *assembly)
1331 {
1332     VTableFixup *vtable_fixups;
1333     ULONG vtable_fixup_count, i;
1334
1335     assembly_get_vtable_fixups(assembly, &vtable_fixups, &vtable_fixup_count);
1336     if (CAN_FIXUP_VTABLE)
1337         for (i=0; i<vtable_fixup_count; i++)
1338             FixupVTableEntry(hmodule, &vtable_fixups[i]);
1339     else if (vtable_fixup_count)
1340         FIXME("cannot fixup vtable; expect a crash\n");
1341 }
1342
1343 static void FixupVTable(HMODULE hmodule)
1344 {
1345     ASSEMBLY *assembly;
1346     HRESULT hr;
1347
1348     hr = assembly_from_hmodule(&assembly, hmodule);
1349     if (SUCCEEDED(hr))
1350     {
1351         FixupVTable_Assembly(hmodule, assembly);
1352         assembly_release(assembly);
1353     }
1354     else
1355         ERR("failed to read CLR headers, hr=%x\n", hr);
1356 }
1357
1358 __int32 WINAPI _CorExeMain(void)
1359 {
1360     int exit_code;
1361     int argc;
1362     char **argv;
1363     MonoDomain *domain=NULL;
1364     MonoImage *image;
1365     MonoImageOpenStatus status;
1366     MonoAssembly *assembly=NULL;
1367     WCHAR filename[MAX_PATH];
1368     char *filenameA;
1369     ICLRRuntimeInfo *info;
1370     RuntimeHost *host;
1371     HRESULT hr;
1372     int i;
1373
1374     get_utf8_args(&argc, &argv);
1375
1376     GetModuleFileNameW(NULL, filename, MAX_PATH);
1377
1378     TRACE("%s", debugstr_w(filename));
1379     for (i=0; i<argc; i++)
1380         TRACE(" %s", debugstr_a(argv[i]));
1381     TRACE("\n");
1382
1383     filenameA = WtoA(filename);
1384     if (!filenameA)
1385         return -1;
1386
1387     FixupVTable(GetModuleHandleW(NULL));
1388
1389     hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
1390
1391     if (SUCCEEDED(hr))
1392     {
1393         hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
1394
1395         if (SUCCEEDED(hr))
1396         {
1397             WCHAR config_file[MAX_PATH];
1398             static const WCHAR dotconfig[] = {'.','c','o','n','f','i','g',0};
1399
1400             strcpyW(config_file, filename);
1401             strcatW(config_file, dotconfig);
1402
1403             hr = RuntimeHost_GetDefaultDomain(host, config_file, &domain);
1404         }
1405
1406         if (SUCCEEDED(hr))
1407         {
1408             image = mono_image_open_from_module_handle(GetModuleHandleW(NULL),
1409                 filenameA, 1, &status);
1410
1411             if (image)
1412                 assembly = mono_assembly_load_from(image, filenameA, &status);
1413
1414             if (assembly)
1415             {
1416                 mono_trace_set_assembly(assembly);
1417
1418                 exit_code = mono_jit_exec(domain, assembly, argc, argv);
1419             }
1420             else
1421             {
1422                 ERR("couldn't load %s, status=%d\n", debugstr_w(filename), status);
1423                 exit_code = -1;
1424             }
1425
1426             RuntimeHost_DeleteDomain(host, domain);
1427         }
1428         else
1429             exit_code = -1;
1430
1431         ICLRRuntimeInfo_Release(info);
1432     }
1433     else
1434         exit_code = -1;
1435
1436     HeapFree(GetProcessHeap(), 0, argv);
1437
1438     if (domain)
1439     {
1440         mono_thread_manage();
1441         mono_runtime_quit();
1442     }
1443
1444     return exit_code;
1445 }
1446
1447 BOOL WINAPI _CorDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1448 {
1449     ASSEMBLY *assembly=NULL;
1450     HRESULT hr;
1451
1452     TRACE("(%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
1453
1454     hr = assembly_from_hmodule(&assembly, hinstDLL);
1455     if (SUCCEEDED(hr))
1456     {
1457         NativeEntryPointFunc NativeEntryPoint=NULL;
1458
1459         assembly_get_native_entrypoint(assembly, &NativeEntryPoint);
1460         if (fdwReason == DLL_PROCESS_ATTACH)
1461         {
1462             if (!NativeEntryPoint)
1463                 DisableThreadLibraryCalls(hinstDLL);
1464             FixupVTable_Assembly(hinstDLL,assembly);
1465         }
1466         assembly_release(assembly);
1467         /* FIXME: clean up the vtables on DLL_PROCESS_DETACH */
1468         if (NativeEntryPoint)
1469             return NativeEntryPoint(hinstDLL, fdwReason, lpvReserved);
1470     }
1471     else
1472         ERR("failed to read CLR headers, hr=%x\n", hr);
1473
1474     return TRUE;
1475 }
1476
1477 /* called from DLL_PROCESS_ATTACH */
1478 void runtimehost_init(void)
1479 {
1480     dll_fixup_heap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);
1481     list_init(&dll_fixups);
1482 }
1483
1484 /* called from DLL_PROCESS_DETACH */
1485 void runtimehost_uninit(void)
1486 {
1487     struct dll_fixup *fixup, *fixup2;
1488
1489     HeapDestroy(dll_fixup_heap);
1490     LIST_FOR_EACH_ENTRY_SAFE(fixup, fixup2, &dll_fixups, struct dll_fixup, entry)
1491     {
1492         HeapFree(GetProcessHeap(), 0, fixup->tokens);
1493         HeapFree(GetProcessHeap(), 0, fixup);
1494     }
1495 }
1496
1497 HRESULT RuntimeHost_Construct(CLRRuntimeInfo *runtime_version, RuntimeHost** result)
1498 {
1499     RuntimeHost *This;
1500
1501     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
1502     if ( !This )
1503         return E_OUTOFMEMORY;
1504
1505     This->ICorRuntimeHost_iface.lpVtbl = &corruntimehost_vtbl;
1506     This->ICLRRuntimeHost_iface.lpVtbl = &CLRHostVtbl;
1507
1508     This->ref = 1;
1509     This->version = runtime_version;
1510     list_init(&This->domains);
1511     This->default_domain = NULL;
1512     InitializeCriticalSection(&This->lock);
1513     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RuntimeHost.lock");
1514
1515     *result = This;
1516
1517     return S_OK;
1518 }
1519
1520 HRESULT RuntimeHost_GetInterface(RuntimeHost *This, REFCLSID clsid, REFIID riid, void **ppv)
1521 {
1522     IUnknown *unk;
1523     HRESULT hr;
1524
1525     if (IsEqualGUID(clsid, &CLSID_CorRuntimeHost))
1526     {
1527         unk = (IUnknown*)&This->ICorRuntimeHost_iface;
1528         IUnknown_AddRef(unk);
1529     }
1530     else if (IsEqualGUID(clsid, &CLSID_CLRRuntimeHost))
1531     {
1532         unk = (IUnknown*)&This->ICLRRuntimeHost_iface;
1533         IUnknown_AddRef(unk);
1534     }
1535     else if (IsEqualGUID(clsid, &CLSID_CorMetaDataDispenser) ||
1536              IsEqualGUID(clsid, &CLSID_CorMetaDataDispenserRuntime))
1537     {
1538         hr = MetaDataDispenser_CreateInstance(&unk);
1539         if (FAILED(hr))
1540             return hr;
1541     }
1542     else if (IsEqualGUID(clsid, &CLSID_CLRDebuggingLegacy))
1543     {
1544         hr = CorDebug_Create(&This->ICLRRuntimeHost_iface, &unk);
1545         if (FAILED(hr))
1546             return hr;
1547     }
1548     else
1549         unk = NULL;
1550
1551     if (unk)
1552     {
1553         hr = IUnknown_QueryInterface(unk, riid, ppv);
1554
1555         IUnknown_Release(unk);
1556
1557         return hr;
1558     }
1559     else
1560         FIXME("not implemented for class %s\n", debugstr_guid(clsid));
1561
1562     return CLASS_E_CLASSNOTAVAILABLE;
1563 }
1564
1565 #define CHARS_IN_GUID 39
1566 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
1567
1568 HRESULT create_monodata(REFIID riid, LPVOID *ppObj )
1569 {
1570     static const WCHAR wszAssembly[] = {'A','s','s','e','m','b','l','y',0};
1571     static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0};
1572     static const WCHAR wszClass[] = {'C','l','a','s','s',0};
1573     static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0};
1574     static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
1575     static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
1576     static const WCHAR wszDLL[] = {'.','d','l','l',0};
1577     WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1];
1578     MonoDomain *domain;
1579     MonoAssembly *assembly;
1580     ICLRRuntimeInfo *info = NULL;
1581     RuntimeHost *host;
1582     HRESULT hr;
1583     HKEY key, subkey;
1584     LONG res;
1585     int offset = 0;
1586     DWORD numKeys, keyLength;
1587     WCHAR codebase[MAX_PATH + 8];
1588     WCHAR classname[350], subkeyName[256];
1589     WCHAR filename[MAX_PATH];
1590
1591     DWORD dwBufLen = 350;
1592
1593     lstrcpyW(path, wszCLSIDSlash);
1594     StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
1595     lstrcatW(path, wszInprocServer32);
1596
1597     TRACE("Registry key: %s\n", debugstr_w(path));
1598
1599     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key);
1600     if (res == ERROR_FILE_NOT_FOUND)
1601         return CLASS_E_CLASSNOTAVAILABLE;
1602
1603     res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen);
1604     if(res != ERROR_SUCCESS)
1605     {
1606         WARN("Class value cannot be found.\n");
1607         hr = CLASS_E_CLASSNOTAVAILABLE;
1608         goto cleanup;
1609     }
1610
1611     TRACE("classname (%s)\n", debugstr_w(classname));
1612
1613     dwBufLen = MAX_PATH + 8;
1614     res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen);
1615     if(res == ERROR_SUCCESS)
1616     {
1617         /* Strip file:/// */
1618         if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0)
1619             offset = strlenW(wszFileSlash);
1620
1621         strcpyW(filename, codebase + offset);
1622     }
1623     else
1624     {
1625         WCHAR assemblyname[MAX_PATH + 8];
1626
1627         hr = CLASS_E_CLASSNOTAVAILABLE;
1628         WARN("CodeBase value cannot be found, trying Assembly.\n");
1629         /* get the last subkey of InprocServer32 */
1630         res = RegQueryInfoKeyW(key, 0, 0, 0, &numKeys, 0, 0, 0, 0, 0, 0, 0);
1631         if (res != ERROR_SUCCESS || numKeys == 0)
1632             goto cleanup;
1633         numKeys--;
1634         keyLength = sizeof(subkeyName) / sizeof(WCHAR);
1635         res = RegEnumKeyExW(key, numKeys, subkeyName, &keyLength, 0, 0, 0, 0);
1636         if (res != ERROR_SUCCESS)
1637             goto cleanup;
1638         res = RegOpenKeyExW(key, subkeyName, 0, KEY_READ, &subkey);
1639         if (res != ERROR_SUCCESS)
1640             goto cleanup;
1641         dwBufLen = MAX_PATH + 8;
1642         res = RegGetValueW(subkey, NULL, wszAssembly, RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen);
1643         RegCloseKey(subkey);
1644         if (res != ERROR_SUCCESS)
1645             goto cleanup;
1646
1647         hr = get_file_from_strongname(assemblyname, filename, MAX_PATH);
1648         if (FAILED(hr))
1649         {
1650             /*
1651              * The registry doesn't have a CodeBase entry and it's not in the GAC.
1652              *
1653              * Use the Assembly Key to retrieve the filename.
1654              *    Assembly : REG_SZ : AssemblyName, Version=X.X.X.X, Culture=neutral, PublicKeyToken=null
1655              */
1656             WCHAR *ns;
1657
1658             WARN("Attempt to load from the application directory.\n");
1659             GetModuleFileNameW(NULL, filename, MAX_PATH);
1660             ns = strrchrW(filename, '\\');
1661             *(ns+1) = '\0';
1662
1663             ns = strchrW(assemblyname, ',');
1664             *(ns) = '\0';
1665             strcatW(filename, assemblyname);
1666             *(ns) = '.';
1667             strcatW(filename, wszDLL);
1668         }
1669     }
1670
1671     TRACE("filename (%s)\n", debugstr_w(filename));
1672
1673     *ppObj = NULL;
1674
1675
1676     hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
1677     if (SUCCEEDED(hr))
1678     {
1679         hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
1680
1681         if (SUCCEEDED(hr))
1682             hr = RuntimeHost_GetDefaultDomain(host, NULL, &domain);
1683
1684         if (SUCCEEDED(hr))
1685         {
1686             MonoImage *image;
1687             MonoClass *klass;
1688             MonoObject *result;
1689             IUnknown *unk = NULL;
1690             char *filenameA, *ns;
1691             char *classA;
1692
1693             hr = CLASS_E_CLASSNOTAVAILABLE;
1694
1695             mono_thread_attach(domain);
1696
1697             filenameA = WtoA(filename);
1698             assembly = mono_domain_assembly_open(domain, filenameA);
1699             HeapFree(GetProcessHeap(), 0, filenameA);
1700             if (!assembly)
1701             {
1702                 ERR("Cannot open assembly %s\n", filenameA);
1703                 goto cleanup;
1704             }
1705
1706             image = mono_assembly_get_image(assembly);
1707             if (!image)
1708             {
1709                 ERR("Couldn't get assembly image\n");
1710                 goto cleanup;
1711             }
1712
1713             classA = WtoA(classname);
1714             ns = strrchr(classA, '.');
1715             *ns = '\0';
1716
1717             klass = mono_class_from_name(image, classA, ns+1);
1718             HeapFree(GetProcessHeap(), 0, classA);
1719             if (!klass)
1720             {
1721                 ERR("Couldn't get class from image\n");
1722                 goto cleanup;
1723             }
1724
1725             /*
1726              * Use the default constructor for the .NET class.
1727              */
1728             result = mono_object_new(domain, klass);
1729             mono_runtime_object_init(result);
1730
1731             hr = RuntimeHost_GetIUnknownForObject(host, result, &unk);
1732             if (SUCCEEDED(hr))
1733             {
1734                 hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj);
1735
1736                 IUnknown_Release(unk);
1737             }
1738             else
1739                 hr = CLASS_E_CLASSNOTAVAILABLE;
1740         }
1741         else
1742             hr = CLASS_E_CLASSNOTAVAILABLE;
1743     }
1744     else
1745         hr = CLASS_E_CLASSNOTAVAILABLE;
1746
1747 cleanup:
1748     if(info)
1749         ICLRRuntimeInfo_Release(info);
1750
1751     RegCloseKey(key);
1752
1753     return hr;
1754 }