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_AddDomain(RuntimeHost *This, MonoDomain **result)
  72 {
  73     struct DomainEntry *entry;
  74     char *mscorlib_path;
  75     HRESULT res=S_OK;
  76
  77     EnterCriticalSection(&This->lock);
  78
  79     entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
  80     if (!entry)
  81     {
  82         res = E_OUTOFMEMORY;
  83         goto end;
  84     }
  85
  86     mscorlib_path = WtoA(This->version->mscorlib_path);
  87     if (!mscorlib_path)
  88     {
  89         HeapFree(GetProcessHeap(), 0, entry);
  90         res = E_OUTOFMEMORY;
  91         goto end;
  92     }
  93
  94     entry->domain = mono_jit_init(mscorlib_path);
  95
  96     HeapFree(GetProcessHeap(), 0, mscorlib_path);
  97
  98     if (!entry->domain)
  99     {
 100         HeapFree(GetProcessHeap(), 0, entry);
 101         res = E_FAIL;
 102         goto end;
 103     }
 104
 105     is_mono_started = TRUE;
 106
 107     list_add_tail(&This->domains, &entry->entry);
 108
 109     *result = entry->domain;
 110
 111 end:
 112     LeaveCriticalSection(&This->lock);
 113
 114     return res;
 115 }
 116
 117 static HRESULT RuntimeHost_GetDefaultDomain(RuntimeHost *This, MonoDomain **result)
 118 {
 119     HRESULT res=S_OK;
 120
 121     EnterCriticalSection(&This->lock);
 122
 123     if (This->default_domain) goto end;
 124
 125     res = RuntimeHost_AddDomain(This, &This->default_domain);
 126
 127 end:
 128     *result = This->default_domain;
 129
 130     LeaveCriticalSection(&This->lock);
 131
 132     return res;
 133 }
 134
 135 static void RuntimeHost_DeleteDomain(RuntimeHost *This, MonoDomain *domain)
 136 {
 137     struct DomainEntry *entry;
 138
 139     EnterCriticalSection(&This->lock);
 140
 141     LIST_FOR_EACH_ENTRY(entry, &This->domains, struct DomainEntry, entry)
 142     {
 143         if (entry->domain == domain)
 144         {
 145             list_remove(&entry->entry);
 146             if (This->default_domain == domain)
 147                 This->default_domain = NULL;
 148             HeapFree(GetProcessHeap(), 0, entry);
 149             break;
 150         }
 151     }
 152
 153     LeaveCriticalSection(&This->lock);
 154 }
 155
 156 static HRESULT RuntimeHost_GetIUnknownForDomain(RuntimeHost *This, MonoDomain *domain, IUnknown **punk)
 157 {
 158     HRESULT hr;
 159     void *args[1];
 160     MonoAssembly *assembly;
 161     MonoImage *image;
 162     MonoClass *klass;
 163     MonoMethod *method;
 164     MonoObject *appdomain_object;
 165     IUnknown *unk;
 166
 167     mono_thread_attach(domain);
 168
 169     assembly = mono_domain_assembly_open(domain, "mscorlib");
 170     if (!assembly)
 171     {
 172         ERR("Cannot load mscorlib\n");
 173         return E_FAIL;
 174     }
 175
 176     image = mono_assembly_get_image(assembly);
 177     if (!image)
 178     {
 179         ERR("Couldn't get assembly image\n");
 180         return E_FAIL;
 181     }
 182
 183     klass = mono_class_from_name(image, "System", "AppDomain");
 184     if (!klass)
 185     {
 186         ERR("Couldn't get class from image\n");
 187         return E_FAIL;
 188     }
 189
 190     method = mono_class_get_method_from_name(klass, "get_CurrentDomain", 0);
 191     if (!method)
 192     {
 193         ERR("Couldn't get method from class\n");
 194         return E_FAIL;
 195     }
 196
 197     args[0] = NULL;
 198     appdomain_object = mono_runtime_invoke(method, NULL, args, NULL);
 199     if (!appdomain_object)
 200     {
 201         ERR("Couldn't get result pointer\n");
 202         return E_FAIL;
 203     }
 204
 205     hr = RuntimeHost_GetIUnknownForObject(This, appdomain_object, &unk);
 206
 207     if (SUCCEEDED(hr))
 208     {
 209         hr = IUnknown_QueryInterface(unk, &IID__AppDomain, (void**)punk);
 210
 211         IUnknown_Release(unk);
 212     }
 213
 214     return hr;
 215 }
 216
 217 void RuntimeHost_ExitProcess(RuntimeHost *This, INT exitcode)
 218 {
 219     HRESULT hr;
 220     void *args[2];
 221     MonoDomain *domain;
 222     MonoAssembly *assembly;
 223     MonoImage *image;
 224     MonoClass *klass;
 225     MonoMethod *method;
 226
 227     hr = RuntimeHost_GetDefaultDomain(This, &domain);
 228     if (FAILED(hr))
 229     {
 230         ERR("Cannot get domain, hr=%x\n", hr);
 231         return;
 232     }
 233
 234     mono_thread_attach(domain);
 235
 236     assembly = mono_domain_assembly_open(domain, "mscorlib");
 237     if (!assembly)
 238     {
 239         ERR("Cannot load mscorlib\n");
 240         return;
 241     }
 242
 243     image = mono_assembly_get_image(assembly);
 244     if (!image)
 245     {
 246         ERR("Couldn't get assembly image\n");
 247         return;
 248     }
 249
 250     klass = mono_class_from_name(image, "System", "Environment");
 251     if (!klass)
 252     {
 253         ERR("Couldn't get class from image\n");
 254         return;
 255     }
 256
 257     method = mono_class_get_method_from_name(klass, "Exit", 1);
 258     if (!method)
 259     {
 260         ERR("Couldn't get method from class\n");
 261         return;
 262     }
 263
 264     args[0] = &exitcode;
 265     args[1] = NULL;
 266     mono_runtime_invoke(method, NULL, args, NULL);
 267
 268     ERR("Process should have exited\n");
 269 }
 270
 271 static inline RuntimeHost *impl_from_ICLRRuntimeHost( ICLRRuntimeHost *iface )
 272 {
 273     return CONTAINING_RECORD(iface, RuntimeHost, ICLRRuntimeHost_iface);
 274 }
 275
 276 static inline RuntimeHost *impl_from_ICorRuntimeHost( ICorRuntimeHost *iface )
 277 {
 278     return CONTAINING_RECORD(iface, RuntimeHost, ICorRuntimeHost_iface);
 279 }
 280
 281 /*** IUnknown methods ***/
 282 static HRESULT WINAPI corruntimehost_QueryInterface(ICorRuntimeHost* iface,
 283         REFIID riid,
 284         void **ppvObject)
 285 {
 286     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 287     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 288
 289     if ( IsEqualGUID( riid, &IID_ICorRuntimeHost ) ||
 290          IsEqualGUID( riid, &IID_IUnknown ) )
 291     {
 292         *ppvObject = iface;
 293     }
 294     else
 295     {
 296         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 297         return E_NOINTERFACE;
 298     }
 299
 300     ICorRuntimeHost_AddRef( iface );
 301
 302     return S_OK;
 303 }
 304
 305 static ULONG WINAPI corruntimehost_AddRef(ICorRuntimeHost* iface)
 306 {
 307     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 308
 309     return InterlockedIncrement( &This->ref );
 310 }
 311
 312 static ULONG WINAPI corruntimehost_Release(ICorRuntimeHost* iface)
 313 {
 314     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 315     ULONG ref;
 316
 317     ref = InterlockedDecrement( &This->ref );
 318
 319     return ref;
 320 }
 321
 322 /*** ICorRuntimeHost methods ***/
 323 static HRESULT WINAPI corruntimehost_CreateLogicalThreadState(
 324                     ICorRuntimeHost* iface)
 325 {
 326     FIXME("stub %p\n", iface);
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI corruntimehost_DeleteLogicalThreadState(
 331                     ICorRuntimeHost* iface)
 332 {
 333     FIXME("stub %p\n", iface);
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI corruntimehost_SwitchInLogicalThreadState(
 338                     ICorRuntimeHost* iface,
 339                     DWORD *fiberCookie)
 340 {
 341     FIXME("stub %p\n", iface);
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI corruntimehost_SwitchOutLogicalThreadState(
 346                     ICorRuntimeHost* iface,
 347                     DWORD **fiberCookie)
 348 {
 349     FIXME("stub %p\n", iface);
 350     return E_NOTIMPL;
 351 }
 352
 353 static HRESULT WINAPI corruntimehost_LocksHeldByLogicalThread(
 354                     ICorRuntimeHost* iface,
 355                     DWORD *pCount)
 356 {
 357     FIXME("stub %p\n", iface);
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI corruntimehost_MapFile(
 362     ICorRuntimeHost* iface,
 363     HANDLE hFile,
 364     HMODULE *mapAddress)
 365 {
 366     FIXME("stub %p\n", iface);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI corruntimehost_GetConfiguration(
 371     ICorRuntimeHost* iface,
 372     ICorConfiguration **pConfiguration)
 373 {
 374     FIXME("stub %p\n", iface);
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI corruntimehost_Start(
 379     ICorRuntimeHost* iface)
 380 {
 381     FIXME("stub %p\n", iface);
 382     return S_OK;
 383 }
 384
 385 static HRESULT WINAPI corruntimehost_Stop(
 386     ICorRuntimeHost* iface)
 387 {
 388     FIXME("stub %p\n", iface);
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI corruntimehost_CreateDomain(
 393     ICorRuntimeHost* iface,
 394     LPCWSTR friendlyName,
 395     IUnknown *identityArray,
 396     IUnknown **appDomain)
 397 {
 398     FIXME("stub %p\n", iface);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI corruntimehost_GetDefaultDomain(
 403     ICorRuntimeHost* iface,
 404     IUnknown **pAppDomain)
 405 {
 406     RuntimeHost *This = impl_from_ICorRuntimeHost( iface );
 407     HRESULT hr;
 408     MonoDomain *domain;
 409
 410     TRACE("(%p)\n", iface);
 411
 412     hr = RuntimeHost_GetDefaultDomain(This, &domain);
 413
 414     if (SUCCEEDED(hr))
 415     {
 416         hr = RuntimeHost_GetIUnknownForDomain(This, domain, pAppDomain);
 417     }
 418
 419     return hr;
 420 }
 421
 422 static HRESULT WINAPI corruntimehost_EnumDomains(
 423     ICorRuntimeHost* iface,
 424     HDOMAINENUM *hEnum)
 425 {
 426     FIXME("stub %p\n", iface);
 427     return E_NOTIMPL;
 428 }
 429
 430 static HRESULT WINAPI corruntimehost_NextDomain(
 431     ICorRuntimeHost* iface,
 432     HDOMAINENUM hEnum,
 433     IUnknown **appDomain)
 434 {
 435     FIXME("stub %p\n", iface);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI corruntimehost_CloseEnum(
 440     ICorRuntimeHost* iface,
 441     HDOMAINENUM hEnum)
 442 {
 443     FIXME("stub %p\n", iface);
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI corruntimehost_CreateDomainEx(
 448     ICorRuntimeHost* iface,
 449     LPCWSTR friendlyName,
 450     IUnknown *setup,
 451     IUnknown *evidence,
 452     IUnknown **appDomain)
 453 {
 454     FIXME("stub %p\n", iface);
 455     return E_NOTIMPL;
 456 }
 457
 458 static HRESULT WINAPI corruntimehost_CreateDomainSetup(
 459     ICorRuntimeHost* iface,
 460     IUnknown **appDomainSetup)
 461 {
 462     FIXME("stub %p\n", iface);
 463     return E_NOTIMPL;
 464 }
 465
 466 static HRESULT WINAPI corruntimehost_CreateEvidence(
 467     ICorRuntimeHost* iface,
 468     IUnknown **evidence)
 469 {
 470     FIXME("stub %p\n", iface);
 471     return E_NOTIMPL;
 472 }
 473
 474 static HRESULT WINAPI corruntimehost_UnloadDomain(
 475     ICorRuntimeHost* iface,
 476     IUnknown *appDomain)
 477 {
 478     FIXME("stub %p\n", iface);
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI corruntimehost_CurrentDomain(
 483     ICorRuntimeHost* iface,
 484     IUnknown **appDomain)
 485 {
 486     FIXME("stub %p\n", iface);
 487     return E_NOTIMPL;
 488 }
 489
 490 static const struct ICorRuntimeHostVtbl corruntimehost_vtbl =
 491 {
 492     corruntimehost_QueryInterface,
 493     corruntimehost_AddRef,
 494     corruntimehost_Release,
 495     corruntimehost_CreateLogicalThreadState,
 496     corruntimehost_DeleteLogicalThreadState,
 497     corruntimehost_SwitchInLogicalThreadState,
 498     corruntimehost_SwitchOutLogicalThreadState,
 499     corruntimehost_LocksHeldByLogicalThread,
 500     corruntimehost_MapFile,
 501     corruntimehost_GetConfiguration,
 502     corruntimehost_Start,
 503     corruntimehost_Stop,
 504     corruntimehost_CreateDomain,
 505     corruntimehost_GetDefaultDomain,
 506     corruntimehost_EnumDomains,
 507     corruntimehost_NextDomain,
 508     corruntimehost_CloseEnum,
 509     corruntimehost_CreateDomainEx,
 510     corruntimehost_CreateDomainSetup,
 511     corruntimehost_CreateEvidence,
 512     corruntimehost_UnloadDomain,
 513     corruntimehost_CurrentDomain
 514 };
 515
 516 static HRESULT WINAPI CLRRuntimeHost_QueryInterface(ICLRRuntimeHost* iface,
 517         REFIID riid,
 518         void **ppvObject)
 519 {
 520     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 521     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 522
 523     if ( IsEqualGUID( riid, &IID_ICLRRuntimeHost ) ||
 524          IsEqualGUID( riid, &IID_IUnknown ) )
 525     {
 526         *ppvObject = iface;
 527     }
 528     else
 529     {
 530         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 531         return E_NOINTERFACE;
 532     }
 533
 534     ICLRRuntimeHost_AddRef( iface );
 535
 536     return S_OK;
 537 }
 538
 539 static ULONG WINAPI CLRRuntimeHost_AddRef(ICLRRuntimeHost* iface)
 540 {
 541     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 542     return ICorRuntimeHost_AddRef(&This->ICorRuntimeHost_iface);
 543 }
 544
 545 static ULONG WINAPI CLRRuntimeHost_Release(ICLRRuntimeHost* iface)
 546 {
 547     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 548     return ICorRuntimeHost_Release(&This->ICorRuntimeHost_iface);
 549 }
 550
 551 static HRESULT WINAPI CLRRuntimeHost_Start(ICLRRuntimeHost* iface)
 552 {
 553     FIXME("(%p)\n", iface);
 554     return E_NOTIMPL;
 555 }
 556
 557 static HRESULT WINAPI CLRRuntimeHost_Stop(ICLRRuntimeHost* iface)
 558 {
 559     FIXME("(%p)\n", iface);
 560     return E_NOTIMPL;
 561 }
 562
 563 static HRESULT WINAPI CLRRuntimeHost_SetHostControl(ICLRRuntimeHost* iface,
 564     IHostControl *pHostControl)
 565 {
 566     FIXME("(%p,%p)\n", iface, pHostControl);
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI CLRRuntimeHost_GetCLRControl(ICLRRuntimeHost* iface,
 571     ICLRControl **pCLRControl)
 572 {
 573     FIXME("(%p,%p)\n", iface, pCLRControl);
 574     return E_NOTIMPL;
 575 }
 576
 577 static HRESULT WINAPI CLRRuntimeHost_UnloadAppDomain(ICLRRuntimeHost* iface,
 578     DWORD dwAppDomainId, BOOL fWaitUntilDone)
 579 {
 580     FIXME("(%p,%u,%i)\n", iface, dwAppDomainId, fWaitUntilDone);
 581     return E_NOTIMPL;
 582 }
 583
 584 static HRESULT WINAPI CLRRuntimeHost_ExecuteInAppDomain(ICLRRuntimeHost* iface,
 585     DWORD dwAppDomainId, FExecuteInAppDomainCallback pCallback, void *cookie)
 586 {
 587     FIXME("(%p,%u,%p,%p)\n", iface, dwAppDomainId, pCallback, cookie);
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT WINAPI CLRRuntimeHost_GetCurrentAppDomainId(ICLRRuntimeHost* iface,
 592     DWORD *pdwAppDomainId)
 593 {
 594     FIXME("(%p,%p)\n", iface, pdwAppDomainId);
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI CLRRuntimeHost_ExecuteApplication(ICLRRuntimeHost* iface,
 599     LPCWSTR pwzAppFullName, DWORD dwManifestPaths, LPCWSTR *ppwzManifestPaths,
 600     DWORD dwActivationData, LPCWSTR *ppwzActivationData, int *pReturnValue)
 601 {
 602     FIXME("(%p,%s,%u,%u)\n", iface, debugstr_w(pwzAppFullName), dwManifestPaths, dwActivationData);
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI CLRRuntimeHost_ExecuteInDefaultAppDomain(ICLRRuntimeHost* iface,
 607     LPCWSTR pwzAssemblyPath, LPCWSTR pwzTypeName, LPCWSTR pwzMethodName,
 608     LPCWSTR pwzArgument, DWORD *pReturnValue)
 609 {
 610     RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
 611     HRESULT hr;
 612     MonoDomain *domain;
 613     MonoAssembly *assembly;
 614     MonoImage *image;
 615     MonoClass *klass;
 616     MonoMethod *method;
 617     MonoObject *result;
 618     MonoString *str;
 619     void *args[2];
 620     char *filenameA = NULL, *classA = NULL, *methodA = NULL;
 621     char *argsA = NULL, *ns;
 622
 623     TRACE("(%p,%s,%s,%s,%s)\n", iface, debugstr_w(pwzAssemblyPath),
 624         debugstr_w(pwzTypeName), debugstr_w(pwzMethodName), debugstr_w(pwzArgument));
 625
 626     hr = RuntimeHost_GetDefaultDomain(This, &domain);
 627     if(hr != S_OK)
 628     {
 629         ERR("Couldn't get Default Domain\n");
 630         return hr;
 631     }
 632
 633     hr = E_FAIL;
 634
 635     mono_thread_attach(domain);
 636
 637     filenameA = WtoA(pwzAssemblyPath);
 638     assembly = mono_domain_assembly_open(domain, filenameA);
 639     if (!assembly)
 640     {
 641         ERR("Cannot open assembly %s\n", filenameA);
 642         goto cleanup;
 643     }
 644
 645     image = mono_assembly_get_image(assembly);
 646     if (!image)
 647     {
 648         ERR("Couldn't get assembly image\n");
 649         goto cleanup;
 650     }
 651
 652     classA = WtoA(pwzTypeName);
 653     ns = strrchr(classA, '.');
 654     *ns = '\0';
 655     klass = mono_class_from_name(image, classA, ns+1);
 656     if (!klass)
 657     {
 658         ERR("Couldn't get class from image\n");
 659         goto cleanup;
 660     }
 661
 662     methodA = WtoA(pwzMethodName);
 663     method = mono_class_get_method_from_name(klass, methodA, 1);
 664     if (!method)
 665     {
 666         ERR("Couldn't get method from class\n");
 667         goto cleanup;
 668     }
 669
 670     /* The .NET function we are calling has the following declaration
 671      *   public static int functionName(String param)
 672      */
 673     argsA = WtoA(pwzArgument);
 674     str = mono_string_new(domain, argsA);
 675     args[0] = str;
 676     args[1] = NULL;
 677     result = mono_runtime_invoke(method, NULL, args, NULL);
 678     if (!result)
 679         ERR("Couldn't get result pointer\n");
 680     else
 681     {
 682         *pReturnValue = *(DWORD*)mono_object_unbox(result);
 683         hr = S_OK;
 684     }
 685
 686 cleanup:
 687     HeapFree(GetProcessHeap(), 0, filenameA);
 688     HeapFree(GetProcessHeap(), 0, classA);
 689     HeapFree(GetProcessHeap(), 0, argsA);
 690     HeapFree(GetProcessHeap(), 0, methodA);
 691
 692     return hr;
 693 }
 694
 695 static const struct ICLRRuntimeHostVtbl CLRHostVtbl =
 696 {
 697     CLRRuntimeHost_QueryInterface,
 698     CLRRuntimeHost_AddRef,
 699     CLRRuntimeHost_Release,
 700     CLRRuntimeHost_Start,
 701     CLRRuntimeHost_Stop,
 702     CLRRuntimeHost_SetHostControl,
 703     CLRRuntimeHost_GetCLRControl,
 704     CLRRuntimeHost_UnloadAppDomain,
 705     CLRRuntimeHost_ExecuteInAppDomain,
 706     CLRRuntimeHost_GetCurrentAppDomainId,
 707     CLRRuntimeHost_ExecuteApplication,
 708     CLRRuntimeHost_ExecuteInDefaultAppDomain
 709 };
 710
 711 /* Create an instance of a type given its name, by calling its constructor with
 712  * no arguments. Note that result MUST be in the stack, or the garbage
 713  * collector may free it prematurely. */
 714 HRESULT RuntimeHost_CreateManagedInstance(RuntimeHost *This, LPCWSTR name,
 715     MonoDomain *domain, MonoObject **result)
 716 {
 717     HRESULT hr=S_OK;
 718     char *nameA=NULL;
 719     MonoType *type;
 720     MonoClass *klass;
 721     MonoObject *obj;
 722
 723     if (!domain)
 724         hr = RuntimeHost_GetDefaultDomain(This, &domain);
 725
 726     if (SUCCEEDED(hr))
 727     {
 728         nameA = WtoA(name);
 729         if (!nameA)
 730             hr = E_OUTOFMEMORY;
 731     }
 732
 733     if (SUCCEEDED(hr))
 734     {
 735         mono_thread_attach(domain);
 736
 737         type = mono_reflection_type_from_name(nameA, NULL);
 738         if (!type)
 739         {
 740             ERR("Cannot find type %s\n", debugstr_w(name));
 741             hr = E_FAIL;
 742         }
 743     }
 744
 745     if (SUCCEEDED(hr))
 746     {
 747         klass = mono_class_from_mono_type(type);
 748         if (!klass)
 749         {
 750             ERR("Cannot convert type %s to a class\n", debugstr_w(name));
 751             hr = E_FAIL;
 752         }
 753     }
 754
 755     if (SUCCEEDED(hr))
 756     {
 757         obj = mono_object_new(domain, klass);
 758         if (!obj)
 759         {
 760             ERR("Cannot allocate object of type %s\n", debugstr_w(name));
 761             hr = E_FAIL;
 762         }
 763     }
 764
 765     if (SUCCEEDED(hr))
 766     {
 767         /* FIXME: Detect exceptions from the constructor? */
 768         mono_runtime_object_init(obj);
 769         *result = obj;
 770     }
 771
 772     HeapFree(GetProcessHeap(), 0, nameA);
 773
 774     return hr;
 775 }
 776
 777 /* Get an IUnknown pointer for a Mono object.
 778  *
 779  * This is just a "light" wrapper around
 780  * System.Runtime.InteropServices.Marshal:GetIUnknownForObject
 781  *
 782  * NOTE: The IUnknown* is created with a reference to the object.
 783  * Until they have a reference, objects must be in the stack to prevent the
 784  * garbage collector from freeing them.
 785  *
 786  * mono_thread_attach must have already been called for this thread. */
 787 HRESULT RuntimeHost_GetIUnknownForObject(RuntimeHost *This, MonoObject *obj,
 788     IUnknown **ppUnk)
 789 {
 790     MonoDomain *domain;
 791     MonoAssembly *assembly;
 792     MonoImage *image;
 793     MonoClass *klass;
 794     MonoMethod *method;
 795     MonoObject *result;
 796     void *args[2];
 797
 798     domain = mono_object_get_domain(obj);
 799
 800     assembly = mono_domain_assembly_open(domain, "mscorlib");
 801     if (!assembly)
 802     {
 803         ERR("Cannot load mscorlib\n");
 804         return E_FAIL;
 805     }
 806
 807     image = mono_assembly_get_image(assembly);
 808     if (!image)
 809     {
 810         ERR("Couldn't get assembly image\n");
 811         return E_FAIL;
 812     }
 813
 814     klass = mono_class_from_name(image, "System.Runtime.InteropServices", "Marshal");
 815     if (!klass)
 816     {
 817         ERR("Couldn't get class from image\n");
 818         return E_FAIL;
 819     }
 820
 821     method = mono_class_get_method_from_name(klass, "GetIUnknownForObject", 1);
 822     if (!method)
 823     {
 824         ERR("Couldn't get method from class\n");
 825         return E_FAIL;
 826     }
 827
 828     args[0] = obj;
 829     args[1] = NULL;
 830     result = mono_runtime_invoke(method, NULL, args, NULL);
 831     if (!result)
 832     {
 833         ERR("Couldn't get result pointer\n");
 834         return E_FAIL;
 835     }
 836
 837     *ppUnk = *(IUnknown**)mono_object_unbox(result);
 838     if (!*ppUnk)
 839     {
 840         ERR("GetIUnknownForObject returned 0\n");
 841         return E_FAIL;
 842     }
 843
 844     return S_OK;
 845 }
 846
 847 static void get_utf8_args(int *argc, char ***argv)
 848 {
 849     WCHAR **argvw;
 850     int size=0, i;
 851     char *current_arg;
 852
 853     argvw = CommandLineToArgvW(GetCommandLineW(), argc);
 854
 855     for (i=0; i<*argc; i++)
 856     {
 857         size += sizeof(char*);
 858         size += WideCharToMultiByte(CP_UTF8, 0, argvw[i], -1, NULL, 0, NULL, NULL);
 859     }
 860     size += sizeof(char*);
 861
 862     *argv = HeapAlloc(GetProcessHeap(), 0, size);
 863     current_arg = (char*)(*argv + *argc + 1);
 864
 865     for (i=0; i<*argc; i++)
 866     {
 867         (*argv)[i] = current_arg;
 868         current_arg += WideCharToMultiByte(CP_UTF8, 0, argvw[i], -1, current_arg, size, NULL, NULL);
 869     }
 870
 871     (*argv)[*argc] = NULL;
 872
 873     HeapFree(GetProcessHeap(), 0, argvw);
 874 }
 875
 876 #if __i386__
 877
 878 # define CAN_FIXUP_VTABLE 1
 879
 880 #include "pshpack1.h"
 881
 882 struct vtable_fixup_thunk
 883 {
 884     /* push %ecx */
 885     BYTE i7;
 886     /* sub $0x4,%esp */
 887     BYTE i1[3];
 888     /* mov fixup,(%esp) */
 889     BYTE i2[3];
 890     struct dll_fixup *fixup;
 891     /* mov function,%eax */
 892     BYTE i3;
 893     void (CDECL *function)(struct dll_fixup *);
 894     /* call *%eax */
 895     BYTE i4[2];
 896     /* pop %eax */
 897     BYTE i5;
 898     /* pop %ecx */
 899     BYTE i8;
 900     /* jmp *vtable_entry */
 901     BYTE i6[2];
 902     void *vtable_entry;
 903 };
 904
 905 static const struct vtable_fixup_thunk thunk_template = {
 906     0x51,
 907     {0x83,0xec,0x04},
 908     {0xc7,0x04,0x24},
 909     NULL,
 910     0xb8,
 911     NULL,
 912     {0xff,0xd0},
 913     0x58,
 914     0x59,
 915     {0xff,0x25},
 916     NULL
 917 };
 918
 919 #include "poppack.h"
 920
 921 #else /* !defined(__i386__) */
 922
 923 # define CAN_FIXUP_VTABLE 0
 924
 925 struct vtable_fixup_thunk
 926 {
 927     struct dll_fixup *fixup;
 928     void (CDECL *function)(struct dll_fixup *fixup);
 929     void *vtable_entry;
 930 };
 931
 932 static const struct vtable_fixup_thunk thunk_template = {0};
 933
 934 #endif
 935
 936 static void CDECL ReallyFixupVTable(struct dll_fixup *fixup)
 937 {
 938     HRESULT hr=S_OK;
 939     WCHAR filename[MAX_PATH];
 940     ICLRRuntimeInfo *info=NULL;
 941     RuntimeHost *host;
 942     char *filenameA;
 943     MonoImage *image=NULL;
 944     MonoAssembly *assembly=NULL;
 945     MonoImageOpenStatus status=0;
 946     MonoDomain *domain;
 947
 948     if (fixup->done) return;
 949
 950     /* It's possible we'll have two threads doing this at once. This is
 951      * considered preferable to the potential deadlock if we use a mutex. */
 952
 953     GetModuleFileNameW(fixup->dll, filename, MAX_PATH);
 954
 955     TRACE("%p,%p,%s\n", fixup, fixup->dll, debugstr_w(filename));
 956
 957     filenameA = WtoA(filename);
 958     if (!filenameA)
 959         hr = E_OUTOFMEMORY;
 960
 961     if (SUCCEEDED(hr))
 962         hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
 963
 964     if (SUCCEEDED(hr))
 965         hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
 966
 967     if (SUCCEEDED(hr))
 968         hr = RuntimeHost_GetDefaultDomain(host, &domain);
 969
 970     if (SUCCEEDED(hr))
 971     {
 972         mono_thread_attach(domain);
 973
 974         assembly = mono_assembly_open(filenameA, &status);
 975     }
 976
 977     if (assembly)
 978     {
 979         int i;
 980
 981         /* Mono needs an image that belongs to an assembly. */
 982         image = mono_assembly_get_image(assembly);
 983
 984         if (fixup->fixup->type & COR_VTABLE_32BIT)
 985         {
 986             DWORD *vtable = fixup->vtable;
 987             DWORD *tokens = fixup->tokens;
 988             for (i=0; i<fixup->fixup->count; i++)
 989             {
 990                 TRACE("%x\n", tokens[i]);
 991                 vtable[i] = PtrToUint(mono_marshal_get_vtfixup_ftnptr(
 992                     image, tokens[i], fixup->fixup->type));
 993             }
 994         }
 995
 996         fixup->done = TRUE;
 997     }
 998
 999     if (info != NULL)
1000         ICLRRuntimeInfo_Release(info);
1001
1002     HeapFree(GetProcessHeap(), 0, filenameA);
1003
1004     if (!fixup->done)
1005     {
1006         ERR("unable to fixup vtable, hr=%x, status=%d\n", hr, status);
1007         /* If we returned now, we'd get an infinite loop. */
1008         assert(0);
1009     }
1010 }
1011
1012 static void FixupVTableEntry(HMODULE hmodule, VTableFixup *vtable_fixup)
1013 {
1014     /* We can't actually generate code for the functions without loading mono,
1015      * and loading mono inside DllMain is a terrible idea. So we make thunks
1016      * that call ReallyFixupVTable, which will load the runtime and fill in the
1017      * vtable, then do an indirect jump using the (now filled in) vtable. Note
1018      * that we have to keep the thunks around forever, as one of them may get
1019      * called while we're filling in the table, and we can never be sure all
1020      * threads are clear. */
1021     struct dll_fixup *fixup;
1022
1023     fixup = HeapAlloc(GetProcessHeap(), 0, sizeof(*fixup));
1024
1025     fixup->dll = hmodule;
1026     fixup->thunk_code = HeapAlloc(dll_fixup_heap, 0, sizeof(struct vtable_fixup_thunk) * vtable_fixup->count);
1027     fixup->fixup = vtable_fixup;
1028     fixup->vtable = (BYTE*)hmodule + vtable_fixup->rva;
1029     fixup->done = FALSE;
1030
1031     if (vtable_fixup->type & COR_VTABLE_32BIT)
1032     {
1033         DWORD *vtable = fixup->vtable;
1034         DWORD *tokens;
1035         int i;
1036         struct vtable_fixup_thunk *thunks = fixup->thunk_code;
1037
1038         if (sizeof(void*) > 4)
1039             ERR("32-bit fixup in 64-bit mode; broken image?\n");
1040
1041         tokens = fixup->tokens = HeapAlloc(GetProcessHeap(), 0, sizeof(*tokens) * vtable_fixup->count);
1042         memcpy(tokens, vtable, sizeof(*tokens) * vtable_fixup->count);
1043         for (i=0; i<vtable_fixup->count; i++)
1044         {
1045             thunks[i] = thunk_template;
1046             thunks[i].fixup = fixup;
1047             thunks[i].function = ReallyFixupVTable;
1048             thunks[i].vtable_entry = &vtable[i];
1049             vtable[i] = PtrToUint(&thunks[i]);
1050         }
1051     }
1052     else
1053     {
1054         ERR("unsupported vtable fixup flags %x\n", vtable_fixup->type);
1055         HeapFree(dll_fixup_heap, 0, fixup->thunk_code);
1056         HeapFree(GetProcessHeap(), 0, fixup);
1057         return;
1058     }
1059
1060     list_add_tail(&dll_fixups, &fixup->entry);
1061 }
1062
1063 static void FixupVTable(HMODULE hmodule)
1064 {
1065     ASSEMBLY *assembly;
1066     HRESULT hr;
1067     VTableFixup *vtable_fixups;
1068     ULONG vtable_fixup_count, i;
1069
1070     hr = assembly_from_hmodule(&assembly, hmodule);
1071     if (SUCCEEDED(hr))
1072     {
1073         hr = assembly_get_vtable_fixups(assembly, &vtable_fixups, &vtable_fixup_count);
1074         if (CAN_FIXUP_VTABLE)
1075             for (i=0; i<vtable_fixup_count; i++)
1076                 FixupVTableEntry(hmodule, &vtable_fixups[i]);
1077         else if (vtable_fixup_count)
1078             FIXME("cannot fixup vtable; expect a crash\n");
1079
1080         assembly_release(assembly);
1081     }
1082     else
1083         ERR("failed to read CLR headers, hr=%x\n", hr);
1084 }
1085
1086 __int32 WINAPI _CorExeMain(void)
1087 {
1088     int exit_code;
1089     int argc;
1090     char **argv;
1091     MonoDomain *domain=NULL;
1092     MonoImage *image;
1093     MonoImageOpenStatus status;
1094     MonoAssembly *assembly=NULL;
1095     WCHAR filename[MAX_PATH];
1096     char *filenameA;
1097     ICLRRuntimeInfo *info;
1098     RuntimeHost *host;
1099     HRESULT hr;
1100     int i;
1101
1102     get_utf8_args(&argc, &argv);
1103
1104     GetModuleFileNameW(NULL, filename, MAX_PATH);
1105
1106     TRACE("%s", debugstr_w(filename));
1107     for (i=0; i<argc; i++)
1108         TRACE(" %s", debugstr_a(argv[i]));
1109     TRACE("\n");
1110
1111     filenameA = WtoA(filename);
1112     if (!filenameA)
1113         return -1;
1114
1115     FixupVTable(GetModuleHandleW(NULL));
1116
1117     hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
1118
1119     if (SUCCEEDED(hr))
1120     {
1121         hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
1122
1123         if (SUCCEEDED(hr))
1124             hr = RuntimeHost_GetDefaultDomain(host, &domain);
1125
1126         if (SUCCEEDED(hr))
1127         {
1128             image = mono_image_open_from_module_handle(GetModuleHandleW(NULL),
1129                 filenameA, 1, &status);
1130
1131             if (image)
1132                 assembly = mono_assembly_load_from(image, filenameA, &status);
1133
1134             if (assembly)
1135             {
1136                 mono_trace_set_assembly(assembly);
1137
1138                 exit_code = mono_jit_exec(domain, assembly, argc, argv);
1139             }
1140             else
1141             {
1142                 ERR("couldn't load %s, status=%d\n", debugstr_w(filename), status);
1143                 exit_code = -1;
1144             }
1145
1146             RuntimeHost_DeleteDomain(host, domain);
1147         }
1148         else
1149             exit_code = -1;
1150
1151         ICLRRuntimeInfo_Release(info);
1152     }
1153     else
1154         exit_code = -1;
1155
1156     HeapFree(GetProcessHeap(), 0, argv);
1157
1158     if (domain)
1159     {
1160         mono_thread_manage();
1161         mono_jit_cleanup(domain);
1162     }
1163
1164     return exit_code;
1165 }
1166
1167 BOOL WINAPI _CorDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1168 {
1169     TRACE("(%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
1170
1171     switch (fdwReason)
1172     {
1173     case DLL_PROCESS_ATTACH:
1174         DisableThreadLibraryCalls(hinstDLL);
1175         FixupVTable(hinstDLL);
1176         break;
1177     case DLL_PROCESS_DETACH:
1178         /* FIXME: clean up the vtables */
1179         break;
1180     }
1181     return TRUE;
1182 }
1183
1184 /* called from DLL_PROCESS_ATTACH */
1185 void runtimehost_init(void)
1186 {
1187     dll_fixup_heap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);
1188     list_init(&dll_fixups);
1189 }
1190
1191 /* called from DLL_PROCESS_DETACH */
1192 void runtimehost_uninit(void)
1193 {
1194     struct dll_fixup *fixup, *fixup2;
1195
1196     HeapDestroy(dll_fixup_heap);
1197     LIST_FOR_EACH_ENTRY_SAFE(fixup, fixup2, &dll_fixups, struct dll_fixup, entry)
1198     {
1199         HeapFree(GetProcessHeap(), 0, fixup->tokens);
1200         HeapFree(GetProcessHeap(), 0, fixup);
1201     }
1202 }
1203
1204 HRESULT RuntimeHost_Construct(const CLRRuntimeInfo *runtime_version, RuntimeHost** result)
1205 {
1206     RuntimeHost *This;
1207
1208     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
1209     if ( !This )
1210         return E_OUTOFMEMORY;
1211
1212     This->ICorRuntimeHost_iface.lpVtbl = &corruntimehost_vtbl;
1213     This->ICLRRuntimeHost_iface.lpVtbl = &CLRHostVtbl;
1214
1215     This->ref = 1;
1216     This->version = runtime_version;
1217     list_init(&This->domains);
1218     This->default_domain = NULL;
1219     InitializeCriticalSection(&This->lock);
1220     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RuntimeHost.lock");
1221
1222     *result = This;
1223
1224     return S_OK;
1225 }
1226
1227 HRESULT RuntimeHost_GetInterface(RuntimeHost *This, REFCLSID clsid, REFIID riid, void **ppv)
1228 {
1229     IUnknown *unk;
1230     HRESULT hr;
1231
1232     if (IsEqualGUID(clsid, &CLSID_CorRuntimeHost))
1233     {
1234         unk = (IUnknown*)&This->ICorRuntimeHost_iface;
1235         IUnknown_AddRef(unk);
1236     }
1237     else if (IsEqualGUID(clsid, &CLSID_CLRRuntimeHost))
1238     {
1239         unk = (IUnknown*)&This->ICLRRuntimeHost_iface;
1240         IUnknown_AddRef(unk);
1241     }
1242     else if (IsEqualGUID(clsid, &CLSID_CorMetaDataDispenser) ||
1243              IsEqualGUID(clsid, &CLSID_CorMetaDataDispenserRuntime))
1244     {
1245         hr = MetaDataDispenser_CreateInstance(&unk);
1246         if (FAILED(hr))
1247             return hr;
1248     }
1249     else if (IsEqualGUID(clsid, &CLSID_CLRDebuggingLegacy))
1250     {
1251         hr = CorDebug_Create(&This->ICLRRuntimeHost_iface, &unk);
1252         if (FAILED(hr))
1253             return hr;
1254     }
1255     else
1256         unk = NULL;
1257
1258     if (unk)
1259     {
1260         hr = IUnknown_QueryInterface(unk, riid, ppv);
1261
1262         IUnknown_Release(unk);
1263
1264         return hr;
1265     }
1266     else
1267         FIXME("not implemented for class %s\n", debugstr_guid(clsid));
1268
1269     return CLASS_E_CLASSNOTAVAILABLE;
1270 }
1271
1272 #define CHARS_IN_GUID 39
1273 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
1274
1275 HRESULT create_monodata(REFIID riid, LPVOID *ppObj )
1276 {
1277     static const WCHAR wszAssembly[] = {'A','s','s','e','m','b','l','y',0};
1278     static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0};
1279     static const WCHAR wszClass[] = {'C','l','a','s','s',0};
1280     static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0};
1281     static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
1282     static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
1283     static const WCHAR wszDLL[] = {'.','d','l','l',0};
1284     WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1];
1285     MonoDomain *domain;
1286     MonoAssembly *assembly;
1287     ICLRRuntimeInfo *info = NULL;
1288     RuntimeHost *host;
1289     HRESULT hr;
1290     HKEY key, subkey;
1291     LONG res;
1292     int offset = 0;
1293     DWORD numKeys, keyLength;
1294     WCHAR codebase[MAX_PATH + 8];
1295     WCHAR classname[350], subkeyName[256];
1296     WCHAR filename[MAX_PATH];
1297
1298     DWORD dwBufLen = 350;
1299
1300     lstrcpyW(path, wszCLSIDSlash);
1301     StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
1302     lstrcatW(path, wszInprocServer32);
1303
1304     TRACE("Registry key: %s\n", debugstr_w(path));
1305
1306     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key);
1307     if (res == ERROR_FILE_NOT_FOUND)
1308         return CLASS_E_CLASSNOTAVAILABLE;
1309
1310     res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen);
1311     if(res != ERROR_SUCCESS)
1312     {
1313         WARN("Class value cannot be found.\n");
1314         hr = CLASS_E_CLASSNOTAVAILABLE;
1315         goto cleanup;
1316     }
1317
1318     TRACE("classname (%s)\n", debugstr_w(classname));
1319
1320     dwBufLen = MAX_PATH + 8;
1321     res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen);
1322     if(res == ERROR_SUCCESS)
1323     {
1324         /* Strip file:/// */
1325         if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0)
1326             offset = strlenW(wszFileSlash);
1327
1328         strcpyW(filename, codebase + offset);
1329     }
1330     else
1331     {
1332         WCHAR assemblyname[MAX_PATH + 8];
1333
1334         hr = CLASS_E_CLASSNOTAVAILABLE;
1335         WARN("CodeBase value cannot be found, trying Assembly.\n");
1336         /* get the last subkey of InprocServer32 */
1337         res = RegQueryInfoKeyW(key, 0, 0, 0, &numKeys, 0, 0, 0, 0, 0, 0, 0);
1338         if (res != ERROR_SUCCESS || numKeys == 0)
1339             goto cleanup;
1340         numKeys--;
1341         keyLength = sizeof(subkeyName) / sizeof(WCHAR);
1342         res = RegEnumKeyExW(key, numKeys, subkeyName, &keyLength, 0, 0, 0, 0);
1343         if (res != ERROR_SUCCESS)
1344             goto cleanup;
1345         res = RegOpenKeyExW(key, subkeyName, 0, KEY_READ, &subkey);
1346         if (res != ERROR_SUCCESS)
1347             goto cleanup;
1348         dwBufLen = MAX_PATH + 8;
1349         res = RegGetValueW(subkey, NULL, wszAssembly, RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen);
1350         RegCloseKey(subkey);
1351         if (res != ERROR_SUCCESS)
1352             goto cleanup;
1353
1354         hr = get_file_from_strongname(assemblyname, filename, MAX_PATH);
1355         if (!SUCCEEDED(hr))
1356         {
1357             /*
1358              * The registry doesn't have a CodeBase entry and it's not in the GAC.
1359              *
1360              * Use the Assembly Key to retrieve the filename.
1361              *    Assembly : REG_SZ : AssemblyName, Version=X.X.X.X, Culture=neutral, PublicKeyToken=null
1362              */
1363             WCHAR *ns;
1364
1365             WARN("Attempt to load from the application directory.\n");
1366             GetModuleFileNameW(NULL, filename, MAX_PATH);
1367             ns = strrchrW(filename, '\\');
1368             *(ns+1) = '\0';
1369
1370             ns = strchrW(assemblyname, ',');
1371             *(ns) = '\0';
1372             strcatW(filename, assemblyname);
1373             *(ns) = '.';
1374             strcatW(filename, wszDLL);
1375         }
1376     }
1377
1378     TRACE("filename (%s)\n", debugstr_w(filename));
1379
1380     *ppObj = NULL;
1381
1382
1383     hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
1384     if (SUCCEEDED(hr))
1385     {
1386         hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
1387
1388         if (SUCCEEDED(hr))
1389             hr = RuntimeHost_GetDefaultDomain(host, &domain);
1390
1391         if (SUCCEEDED(hr))
1392         {
1393             MonoImage *image;
1394             MonoClass *klass;
1395             MonoObject *result;
1396             IUnknown *unk = NULL;
1397             char *filenameA, *ns;
1398             char *classA;
1399
1400             hr = CLASS_E_CLASSNOTAVAILABLE;
1401
1402             mono_thread_attach(domain);
1403
1404             filenameA = WtoA(filename);
1405             assembly = mono_domain_assembly_open(domain, filenameA);
1406             HeapFree(GetProcessHeap(), 0, filenameA);
1407             if (!assembly)
1408             {
1409                 ERR("Cannot open assembly %s\n", filenameA);
1410                 goto cleanup;
1411             }
1412
1413             image = mono_assembly_get_image(assembly);
1414             if (!image)
1415             {
1416                 ERR("Couldn't get assembly image\n");
1417                 goto cleanup;
1418             }
1419
1420             classA = WtoA(classname);
1421             ns = strrchr(classA, '.');
1422             *ns = '\0';
1423
1424             klass = mono_class_from_name(image, classA, ns+1);
1425             HeapFree(GetProcessHeap(), 0, classA);
1426             if (!klass)
1427             {
1428                 ERR("Couldn't get class from image\n");
1429                 goto cleanup;
1430             }
1431
1432             /*
1433              * Use the default constructor for the .NET class.
1434              */
1435             result = mono_object_new(domain, klass);
1436             mono_runtime_object_init(result);
1437
1438             hr = RuntimeHost_GetIUnknownForObject(host, result, &unk);
1439             if (SUCCEEDED(hr))
1440             {
1441                 hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj);
1442
1443                 IUnknown_Release(unk);
1444             }
1445             else
1446                 hr = CLASS_E_CLASSNOTAVAILABLE;
1447         }
1448         else
1449             hr = CLASS_E_CLASSNOTAVAILABLE;
1450     }
1451     else
1452         hr = CLASS_E_CLASSNOTAVAILABLE;
1453
1454 cleanup:
1455     if(info)
1456         ICLRRuntimeInfo_Release(info);
1457
1458     RegCloseKey(key);
1459
1460     return hr;
1461 }