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