mono/metadata/coree.c

   1 /*
   2  * coree.c: mscoree.dll functions
   3  *
   4  * Author:
   5  *   Kornel Pal <http://www.kornelpal.hu/>
   6  *
   7  * Copyright (C) 2008 Kornel Pal
   8  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   9  */
  10
  11 #include <config.h>
  12
  13 #ifdef HOST_WIN32
  14
  15 #include <string.h>
  16 #include <glib.h>
  17 #include <mono/io-layer/io-layer.h>
  18 #include <mono/utils/mono-path.h>
  19 #include "cil-coff.h"
  20 #include "metadata-internals.h"
  21 #include "image.h"
  22 #include "assembly.h"
  23 #include "domain-internals.h"
  24 #include "appdomain.h"
  25 #include "object.h"
  26 #include "loader.h"
  27 #include "threads.h"
  28 #include "environment.h"
  29 #include "coree.h"
  30
  31 #include <shellapi.h>
  32
  33 HMODULE coree_module_handle = NULL;
  34
  35 static gboolean init_from_coree = FALSE;
  36
  37 gchar*
  38 mono_get_module_file_name (HMODULE module_handle)
  39 {
  40         gunichar2* file_name;
  41         gchar* file_name_utf8;
  42         DWORD buffer_size;
  43         DWORD size;
  44
  45         buffer_size = 1024;
  46         file_name = g_new (gunichar2, buffer_size);
  47
  48         for (;;) {
  49                 size = GetModuleFileName (module_handle, file_name, buffer_size);
  50                 if (!size) {
  51                         g_free (file_name);
  52                         return NULL;
  53                 }
  54
  55                 g_assert (size <= buffer_size);
  56                 if (size != buffer_size)
  57                         break;
  58
  59                 buffer_size += 1024;
  60                 file_name = g_realloc (file_name, buffer_size * sizeof (gunichar2));
  61         }
  62
  63         file_name_utf8 = g_utf16_to_utf8 (file_name, size, NULL, NULL, NULL);
  64         g_free (file_name);
  65
  66         return file_name_utf8;
  67 }
  68
  69 /* Entry point called by LdrLoadDll of ntdll.dll after _CorValidateImage. */
  70 BOOL STDMETHODCALLTYPE _CorDllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved)
  71 {
  72         MonoAssembly* assembly;
  73         MonoImage* image;
  74         gchar* file_name;
  75         gchar* error;
  76
  77         switch (dwReason)
  78         {
  79         case DLL_PROCESS_ATTACH:
  80                 DisableThreadLibraryCalls (hInst);
  81
  82                 file_name = mono_get_module_file_name (hInst);
  83
  84                 if (mono_get_root_domain ()) {
  85                         image = mono_image_open_from_module_handle (hInst, mono_path_resolve_symlinks (file_name), TRUE, NULL);
  86                 } else {
  87                         init_from_coree = TRUE;
  88                         mono_runtime_load (file_name, NULL);
  89                         error = (gchar*) mono_check_corlib_version ();
  90                         if (error) {
  91                                 g_free (error);
  92                                 g_free (file_name);
  93                                 mono_runtime_quit ();
  94                                 return FALSE;
  95                         }
  96
  97                         image = mono_image_open (file_name, NULL);
  98                         if (image) {
  99                                 image->has_entry_point = TRUE;
 100                                 mono_close_exe_image ();
 101                                 /* Decrement reference count to zero. (Image will not be closed.) */
 102                                 mono_image_close (image);
 103                         }
 104                 }
 105
 106                 if (!image) {
 107                         g_free (file_name);
 108                         return FALSE;
 109                 }
 110
 111                 /*
 112                  * FIXME: Find a better way to call mono_image_fixup_vtable. Only
 113                  * loader trampolines should be used and assembly loading should
 114                  * probably be delayed until the first call to an exported function.
 115                  */
 116                 if (image->tables [MONO_TABLE_ASSEMBLY].rows && ((MonoCLIImageInfo*) image->image_info)->cli_cli_header.ch_vtable_fixups.rva)
 117                         assembly = mono_assembly_open (file_name, NULL);
 118
 119                 g_free (file_name);
 120                 break;
 121         case DLL_PROCESS_DETACH:
 122                 if (lpReserved != NULL)
 123                         /* The process is terminating. */
 124                         return TRUE;
 125                 file_name = mono_get_module_file_name (hInst);
 126                 image = mono_image_loaded (file_name);
 127                 if (image)
 128                         mono_image_close (image);
 129
 130                 g_free (file_name);
 131                 break;
 132         }
 133
 134         return TRUE;
 135 }
 136
 137 /* Called by ntdll.dll reagardless of entry point after _CorValidateImage. */
 138 __int32 STDMETHODCALLTYPE _CorExeMain(void)
 139 {
 140         MonoError error;
 141         MonoDomain* domain;
 142         MonoAssembly* assembly;
 143         MonoImage* image;
 144         MonoMethod* method;
 145         guint32 entry;
 146         gchar* file_name;
 147         gchar* corlib_version_error;
 148         int argc;
 149         gunichar2** argvw;
 150         gchar** argv;
 151         int i;
 152
 153         file_name = mono_get_module_file_name (NULL);
 154         init_from_coree = TRUE;
 155         domain = mono_runtime_load (file_name, NULL);
 156
 157         corlib_version_error = (gchar*) mono_check_corlib_version ();
 158         if (corlib_version_error) {
 159                 g_free (corlib_version_error);
 160                 g_free (file_name);
 161                 MessageBox (NULL, L"Corlib not in sync with this runtime.", NULL, MB_ICONERROR);
 162                 mono_runtime_quit ();
 163                 ExitProcess (1);
 164         }
 165
 166         assembly = mono_assembly_open (file_name, NULL);
 167         mono_close_exe_image ();
 168         if (!assembly) {
 169                 g_free (file_name);
 170                 MessageBox (NULL, L"Cannot open assembly.", NULL, MB_ICONERROR);
 171                 mono_runtime_quit ();
 172                 ExitProcess (1);
 173         }
 174
 175         image = assembly->image;
 176         entry = mono_image_get_entry_point (image);
 177         if (!entry) {
 178                 g_free (file_name);
 179                 MessageBox (NULL, L"Assembly doesn't have an entry point.", NULL, MB_ICONERROR);
 180                 mono_runtime_quit ();
 181                 ExitProcess (1);
 182         }
 183
 184         method = mono_get_method_checked (image, entry, NULL, NULL, &error);
 185         if (method == NULL) {
 186                 g_free (file_name);
 187                 mono_error_cleanup (&error); /* FIXME don't swallow the error */
 188                 MessageBox (NULL, L"The entry point method could not be loaded.", NULL, MB_ICONERROR);
 189                 mono_runtime_quit ();
 190                 ExitProcess (1);
 191         }
 192
 193         argvw = CommandLineToArgvW (GetCommandLine (), &argc);
 194         argv = g_new0 (gchar*, argc);
 195         argv [0] = file_name;
 196         for (i = 1; i < argc; ++i)
 197                 argv [i] = g_utf16_to_utf8 (argvw [i], -1, NULL, NULL, NULL);
 198         LocalFree (argvw);
 199
 200         mono_runtime_run_main (method, argc, argv, NULL);
 201         mono_thread_manage ();
 202
 203         mono_runtime_quit ();
 204
 205         /* return does not terminate the process. */
 206         ExitProcess (mono_environment_exitcode_get ());
 207 }
 208
 209 /* Called by msvcrt.dll when shutting down. */
 210 void STDMETHODCALLTYPE CorExitProcess(int exitCode)
 211 {
 212         /* FIXME: This is not currently supported by the runtime. */
 213 #if 0
 214         if (mono_get_root_domain () && !mono_runtime_is_shutting_down ()) {
 215                 mono_runtime_set_shutting_down ();
 216                 mono_thread_suspend_all_other_threads ();
 217                 mono_runtime_quit ();
 218         }
 219 #endif
 220         ExitProcess (exitCode);
 221 }
 222
 223 /* Called by ntdll.dll before _CorDllMain and _CorExeMain. */
 224 STDAPI _CorValidateImage(PVOID *ImageBase, LPCWSTR FileName)
 225 {
 226         IMAGE_DOS_HEADER* DosHeader;
 227         IMAGE_NT_HEADERS32* NtHeaders32;
 228         IMAGE_DATA_DIRECTORY* CliHeaderDir;
 229 #ifdef _WIN64
 230         IMAGE_NT_HEADERS64* NtHeaders64;
 231         MonoCLIHeader* CliHeader;
 232         DWORD SizeOfHeaders;
 233 #endif
 234         DWORD* Address;
 235         DWORD OldProtect;
 236
 237         DosHeader = (IMAGE_DOS_HEADER*)*ImageBase;
 238         if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE)
 239                 return STATUS_INVALID_IMAGE_FORMAT;
 240
 241         NtHeaders32 = (IMAGE_NT_HEADERS32*)((DWORD_PTR)DosHeader + DosHeader->e_lfanew);
 242         if (NtHeaders32->Signature != IMAGE_NT_SIGNATURE)
 243                 return STATUS_INVALID_IMAGE_FORMAT;
 244
 245 #ifdef _WIN64
 246         NtHeaders64 = (IMAGE_NT_HEADERS64*)NtHeaders32;
 247         if (NtHeaders64->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
 248         {
 249                 if (NtHeaders64->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR)
 250                         return STATUS_INVALID_IMAGE_FORMAT;
 251
 252                 CliHeaderDir = &NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];
 253                 if (!CliHeaderDir->VirtualAddress)
 254                         return STATUS_INVALID_IMAGE_FORMAT;
 255
 256                 CliHeader = (MonoCLIHeader*)((DWORD_PTR)DosHeader + CliHeaderDir->VirtualAddress);
 257                 if (CliHeader->ch_flags & CLI_FLAGS_32BITREQUIRED)
 258                         return STATUS_INVALID_IMAGE_FORMAT;
 259
 260                 if (CliHeader->ch_flags & CLI_FLAGS_ILONLY)
 261                 {
 262                         /* Avoid calling _CorDllMain because imports are not resolved for IL only images. */
 263                         if (NtHeaders64->OptionalHeader.AddressOfEntryPoint != 0)
 264                         {
 265                                 Address = &NtHeaders64->OptionalHeader.AddressOfEntryPoint;
 266                                 if (!VirtualProtect(Address, sizeof(DWORD), PAGE_READWRITE, &OldProtect))
 267                                         return E_UNEXPECTED;
 268                                 *Address = (DWORD)0;
 269                                 if (!VirtualProtect(Address, sizeof(DWORD), OldProtect, &OldProtect))
 270                                         return E_UNEXPECTED;
 271                         }
 272                 }
 273
 274                 return STATUS_SUCCESS;
 275         }
 276
 277         if (NtHeaders32->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
 278                 return STATUS_INVALID_IMAGE_FORMAT;
 279
 280         if (NtHeaders32->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR)
 281                 return STATUS_INVALID_IMAGE_FORMAT;
 282
 283         CliHeaderDir = &NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];
 284         if (!CliHeaderDir->VirtualAddress)
 285                 return STATUS_INVALID_IMAGE_FORMAT;
 286
 287         CliHeader = (MonoCLIHeader*)((DWORD_PTR)DosHeader + CliHeaderDir->VirtualAddress);
 288         if (!(CliHeader->ch_flags & CLI_FLAGS_ILONLY) || (CliHeader->ch_flags & CLI_FLAGS_32BITREQUIRED))
 289                 return STATUS_INVALID_IMAGE_FORMAT;
 290
 291         /* Fixup IMAGE_NT_HEADERS32 to IMAGE_NT_HEADERS64. */
 292         SizeOfHeaders = NtHeaders32->OptionalHeader.SizeOfHeaders;
 293         if (SizeOfHeaders < DosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS64) + (sizeof(IMAGE_SECTION_HEADER) * NtHeaders32->FileHeader.NumberOfSections))
 294                 return STATUS_INVALID_IMAGE_FORMAT;
 295
 296         if (!VirtualProtect(DosHeader, SizeOfHeaders, PAGE_READWRITE, &OldProtect))
 297                 return E_UNEXPECTED;
 298
 299         memmove(NtHeaders64 + 1, IMAGE_FIRST_SECTION(NtHeaders32), sizeof(IMAGE_SECTION_HEADER) * NtHeaders32->FileHeader.NumberOfSections);
 300
 301         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES - 1].Size = 0;
 302         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES - 1].VirtualAddress = 0;
 303         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size;
 304         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress;
 305         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].Size = 0;
 306         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress = 0;
 307         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size = 0;
 308         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress = 0;
 309         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;
 310         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;
 311         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].Size = 0;
 312         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress = 0;
 313         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].Size = 0;
 314         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress = 0;
 315         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].Size = 0;
 316         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].VirtualAddress = 0;
 317         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_ARCHITECTURE].Size = 0;
 318         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_ARCHITECTURE].VirtualAddress = 0;
 319         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
 320         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;
 321         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;
 322         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress;
 323         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size;
 324         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress;
 325         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size = 0;
 326         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = 0;
 327         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size;
 328         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;
 329         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = 0;
 330         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = 0;
 331         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size = 0;
 332         NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress = 0;
 333
 334         NtHeaders64->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 335         NtHeaders64->OptionalHeader.LoaderFlags = NtHeaders32->OptionalHeader.LoaderFlags;
 336         NtHeaders64->OptionalHeader.SizeOfHeapCommit = (ULONGLONG)NtHeaders32->OptionalHeader.SizeOfHeapCommit;
 337         NtHeaders64->OptionalHeader.SizeOfHeapReserve = (ULONGLONG)NtHeaders32->OptionalHeader.SizeOfHeapReserve;
 338         NtHeaders64->OptionalHeader.SizeOfStackCommit = (ULONGLONG)NtHeaders32->OptionalHeader.SizeOfStackCommit;
 339         NtHeaders64->OptionalHeader.SizeOfStackReserve = (ULONGLONG)NtHeaders32->OptionalHeader.SizeOfStackReserve;
 340         NtHeaders64->OptionalHeader.DllCharacteristics = NtHeaders32->OptionalHeader.DllCharacteristics;
 341         NtHeaders64->OptionalHeader.Subsystem = NtHeaders32->OptionalHeader.Subsystem;
 342         NtHeaders64->OptionalHeader.CheckSum = NtHeaders32->OptionalHeader.CheckSum;
 343         NtHeaders64->OptionalHeader.SizeOfHeaders = NtHeaders32->OptionalHeader.SizeOfHeaders;
 344         NtHeaders64->OptionalHeader.SizeOfImage = NtHeaders32->OptionalHeader.SizeOfImage;
 345         NtHeaders64->OptionalHeader.Win32VersionValue = NtHeaders32->OptionalHeader.Win32VersionValue;
 346         NtHeaders64->OptionalHeader.MinorSubsystemVersion = NtHeaders32->OptionalHeader.MinorSubsystemVersion;
 347         NtHeaders64->OptionalHeader.MajorSubsystemVersion = NtHeaders32->OptionalHeader.MajorSubsystemVersion;
 348         NtHeaders64->OptionalHeader.MinorImageVersion = NtHeaders32->OptionalHeader.MinorImageVersion;
 349         NtHeaders64->OptionalHeader.MajorImageVersion = NtHeaders32->OptionalHeader.MajorImageVersion;
 350         NtHeaders64->OptionalHeader.MinorOperatingSystemVersion = NtHeaders32->OptionalHeader.MinorOperatingSystemVersion;
 351         NtHeaders64->OptionalHeader.MajorOperatingSystemVersion = NtHeaders32->OptionalHeader.MajorOperatingSystemVersion;
 352         NtHeaders64->OptionalHeader.FileAlignment = NtHeaders32->OptionalHeader.FileAlignment;
 353         NtHeaders64->OptionalHeader.SectionAlignment = NtHeaders32->OptionalHeader.SectionAlignment;
 354         NtHeaders64->OptionalHeader.ImageBase = (ULONGLONG)NtHeaders32->OptionalHeader.ImageBase;
 355         /* BaseOfCode is at the same offset. */
 356         NtHeaders64->OptionalHeader.AddressOfEntryPoint = 0;
 357         NtHeaders64->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 358         NtHeaders64->FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER64);
 359
 360         if (!VirtualProtect(DosHeader, SizeOfHeaders, OldProtect, &OldProtect))
 361                 return E_UNEXPECTED;
 362 #else
 363         if (NtHeaders32->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
 364                 return STATUS_INVALID_IMAGE_FORMAT;
 365
 366         if (NtHeaders32->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR)
 367                 return STATUS_INVALID_IMAGE_FORMAT;
 368
 369         CliHeaderDir = &NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];
 370         if (!CliHeaderDir->VirtualAddress)
 371                 return STATUS_INVALID_IMAGE_FORMAT;
 372
 373         Address = &NtHeaders32->OptionalHeader.AddressOfEntryPoint;
 374         if (!VirtualProtect(Address, sizeof(DWORD), PAGE_READWRITE, &OldProtect))
 375                 return E_UNEXPECTED;
 376         if (NtHeaders32->FileHeader.Characteristics & IMAGE_FILE_DLL)
 377                 *Address = (DWORD)((DWORD_PTR)&_CorDllMain - (DWORD_PTR)DosHeader);
 378         else
 379                 *Address = (DWORD)((DWORD_PTR)&_CorExeMain - (DWORD_PTR)DosHeader);
 380         if (!VirtualProtect(Address, sizeof(DWORD), OldProtect, &OldProtect))
 381                 return E_UNEXPECTED;
 382 #endif
 383
 384         return STATUS_SUCCESS;
 385 }
 386
 387 /* Called by ntdll.dll. */
 388 STDAPI_(VOID) _CorImageUnloading(PVOID ImageBase)
 389 {
 390         /* Nothing to do. */
 391 }
 392
 393 STDAPI CorBindToRuntimeEx(LPCWSTR pwszVersion, LPCWSTR pwszBuildFlavor, DWORD startupFlags, REFCLSID rclsid, REFIID riid, LPVOID FAR *ppv)
 394 {
 395         if (ppv == NULL)
 396                 return E_POINTER;
 397
 398         *ppv = NULL;
 399         return E_NOTIMPL;
 400 }
 401
 402 STDAPI CorBindToRuntime(LPCWSTR pwszVersion, LPCWSTR pwszBuildFlavor, REFCLSID rclsid, REFIID riid, LPVOID FAR *ppv)
 403 {
 404         return CorBindToRuntimeEx (pwszVersion, pwszBuildFlavor, 0, rclsid, riid, ppv);
 405 }
 406
 407 HMODULE WINAPI MonoLoadImage(LPCWSTR FileName)
 408 {
 409         HANDLE FileHandle;
 410         DWORD FileSize;
 411         HANDLE MapHandle;
 412         IMAGE_DOS_HEADER* DosHeader;
 413         IMAGE_NT_HEADERS32* NtHeaders32;
 414 #ifdef _WIN64
 415         IMAGE_NT_HEADERS64* NtHeaders64;
 416 #endif
 417         HMODULE ModuleHandle;
 418
 419         FileHandle = CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 420         if (FileHandle == INVALID_HANDLE_VALUE)
 421                 return NULL;
 422
 423         FileSize = GetFileSize(FileHandle, NULL);
 424         if (FileSize == INVALID_FILE_SIZE)
 425                 goto CloseFile;
 426
 427         MapHandle = CreateFileMapping(FileHandle, NULL, PAGE_READONLY, 0, 0, NULL);
 428         if (MapHandle == NULL)
 429                 goto CloseFile;
 430
 431         DosHeader = (IMAGE_DOS_HEADER*)MapViewOfFile(MapHandle, FILE_MAP_READ, 0, 0, 0);
 432         if (DosHeader == NULL)
 433                 goto CloseMap;
 434
 435         if (FileSize < sizeof(IMAGE_DOS_HEADER) || DosHeader->e_magic != IMAGE_DOS_SIGNATURE || FileSize < DosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS32))
 436                 goto InvalidImageFormat;
 437
 438         NtHeaders32 = (IMAGE_NT_HEADERS32*)((DWORD_PTR)DosHeader + DosHeader->e_lfanew);
 439         if (NtHeaders32->Signature != IMAGE_NT_SIGNATURE)
 440                 goto InvalidImageFormat;
 441
 442 #ifdef _WIN64
 443         NtHeaders64 = (IMAGE_NT_HEADERS64*)NtHeaders32;
 444         if (NtHeaders64->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
 445         {
 446                 if (FileSize < DosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS64) ||
 447                         NtHeaders64->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR ||
 448                         !NtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress)
 449                                 goto InvalidImageFormat;
 450
 451                 goto ValidImage;
 452         }
 453 #endif
 454
 455         if (NtHeaders32->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC ||
 456                 NtHeaders32->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR ||
 457                 !NtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress)
 458         {
 459 InvalidImageFormat:
 460                 SetLastError(STATUS_INVALID_IMAGE_FORMAT);
 461                 goto UnmapView;
 462         }
 463
 464 #ifdef _WIN64
 465 ValidImage:
 466 #endif
 467         UnmapViewOfFile(DosHeader);
 468         CloseHandle(MapHandle);
 469
 470         ModuleHandle = LoadLibrary(FileName);
 471
 472         CloseHandle(FileHandle);
 473         return ModuleHandle;
 474
 475 UnmapView:
 476         UnmapViewOfFile(DosHeader);
 477 CloseMap:
 478         CloseHandle(MapHandle);
 479 CloseFile:
 480         CloseHandle(FileHandle);
 481         return NULL;
 482 }
 483
 484 typedef struct _EXPORT_FIXUP
 485 {
 486         LPCSTR Name;
 487         union
 488         {
 489                 PVOID Pointer;
 490                 DWORD_PTR DWordPtr;
 491                 BYTE Bytes[sizeof(PVOID)];
 492 #ifdef _M_IA64
 493                 PLABEL_DESCRIPTOR* PLabel;
 494 #endif
 495         } ProcAddress;
 496 } EXPORT_FIXUP;
 497
 498 /* Has to be binary ordered. */
 499 static const EXPORT_FIXUP ExportFixups[] = {
 500         {"CorBindToRuntime", &CorBindToRuntime},
 501         {"CorBindToRuntimeEx", &CorBindToRuntimeEx},
 502         {"CorExitProcess", &CorExitProcess},
 503         {"_CorDllMain", &_CorDllMain},
 504         {"_CorExeMain", &_CorExeMain},
 505         {"_CorImageUnloading", &_CorImageUnloading},
 506         {"_CorValidateImage", &_CorValidateImage},
 507         {NULL, NULL}
 508 };
 509
 510 #define EXPORT_FIXUP_COUNT (sizeof(ExportFixups) / sizeof(EXPORT_FIXUP) - 1)
 511
 512 static HMODULE ExportFixupModuleHandle = NULL;
 513 static DWORD ExportFixupRvas[EXPORT_FIXUP_COUNT];
 514
 515 /* Fixup exported functions of mscoree.dll to our implementations. */
 516 STDAPI MonoFixupCorEE(HMODULE ModuleHandle)
 517 {
 518         IMAGE_DOS_HEADER* DosHeader;
 519         IMAGE_NT_HEADERS* NtHeaders;
 520         IMAGE_DATA_DIRECTORY* ExportDataDir;
 521         IMAGE_EXPORT_DIRECTORY* ExportDir;
 522         DWORD* Functions;
 523         DWORD* Names;
 524         WORD* NameOrdinals;
 525         EXPORT_FIXUP* ExportFixup;
 526         DWORD* ExportFixupRva;
 527         DWORD* Address;
 528         DWORD OldProtect;
 529         DWORD ProcRva;
 530         DWORD i;
 531         int cmp;
 532 #ifdef _WIN64
 533         MEMORY_BASIC_INFORMATION MemoryInfo;
 534         PVOID Region;
 535         PVOID RegionBase;
 536         PVOID MaxRegionBase;
 537 #ifdef _M_IA64
 538         PLABEL_DESCRIPTOR* PLabel;
 539
 540 #define ELEMENT_SIZE sizeof(PLABEL_DESCRIPTOR)
 541 #define REGION_WRITE_PROTECT PAGE_READWRITE
 542 #define REGION_PROTECT PAGE_READ
 543 #else
 544         BYTE* Trampoline;
 545
 546 #define ELEMENT_SIZE 13
 547 #define REGION_WRITE_PROTECT PAGE_EXECUTE_READWRITE
 548 #define REGION_PROTECT PAGE_EXECUTE_READ
 549 #endif
 550 #endif
 551
 552         if (ExportFixupModuleHandle != NULL)
 553                 return ModuleHandle == ExportFixupModuleHandle ? S_OK : E_FAIL;
 554
 555         DosHeader = (IMAGE_DOS_HEADER*)ModuleHandle;
 556         if (DosHeader == NULL)
 557                 return E_POINTER;
 558
 559         if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE)
 560                 return E_INVALIDARG;
 561
 562         NtHeaders = (IMAGE_NT_HEADERS*)((DWORD_PTR)DosHeader + DosHeader->e_lfanew);
 563         if (NtHeaders->Signature != IMAGE_NT_SIGNATURE)
 564                 return E_INVALIDARG;
 565
 566         if (NtHeaders->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
 567                 return E_INVALIDARG;
 568
 569         if (NtHeaders->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_EXPORT)
 570                 return E_FAIL;
 571
 572         ExportDataDir = &NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
 573         if (!ExportDataDir->VirtualAddress)
 574                 return E_FAIL;
 575
 576 #ifdef _WIN64
 577         /* Allocate memory after base address because RVAs are 32-bit unsigned integers. */
 578         RegionBase = DosHeader;
 579         MaxRegionBase = (PVOID)((DWORD_PTR)RegionBase + (DWORD_PTR)(0x100000000L - (ELEMENT_SIZE * (EXPORT_FIXUP_COUNT - 1))));
 580         for (;;)
 581         {
 582                 if (!VirtualQuery(RegionBase, &MemoryInfo, sizeof(MEMORY_BASIC_INFORMATION)))
 583                         return E_UNEXPECTED;
 584                 if (MemoryInfo.State == MEM_FREE && MemoryInfo.RegionSize >= ELEMENT_SIZE * EXPORT_FIXUP_COUNT)
 585                 {
 586                         Region = VirtualAlloc(RegionBase, ELEMENT_SIZE * EXPORT_FIXUP_COUNT, MEM_COMMIT | MEM_RESERVE, REGION_WRITE_PROTECT);
 587                         if (Region != NULL)
 588                                 break;
 589                 }
 590                 RegionBase = (PVOID)((DWORD_PTR)MemoryInfo.BaseAddress + (DWORD_PTR)MemoryInfo.RegionSize);
 591                 if (RegionBase > MaxRegionBase)
 592                         return E_OUTOFMEMORY;
 593         }
 594
 595 #ifdef _M_IA64
 596         PLabel = (PLABEL_DESCRIPTOR*)Region;
 597 #else
 598         Trampoline = (BYTE*)Region;
 599 #endif
 600 #endif
 601
 602         ExportDir = (IMAGE_EXPORT_DIRECTORY*)((DWORD_PTR)DosHeader + ExportDataDir->VirtualAddress);
 603         Functions = (DWORD*)((DWORD_PTR)DosHeader + ExportDir->AddressOfFunctions);
 604         Names = (DWORD*)((DWORD_PTR)DosHeader + ExportDir->AddressOfNames);
 605         NameOrdinals = (WORD*)((DWORD_PTR)DosHeader + ExportDir->AddressOfNameOrdinals);
 606         ExportFixup = (EXPORT_FIXUP*)&ExportFixups;
 607         ExportFixupRva = (DWORD*)&ExportFixupRvas;
 608
 609         for (i = 0; i < ExportDir->NumberOfNames; i++)
 610         {
 611                 cmp = strcmp((LPCSTR)((DWORD_PTR)DosHeader + Names[i]), ExportFixup->Name);
 612                 if (cmp > 0)
 613                         return E_FAIL;
 614
 615                 if (cmp == 0)
 616                 {
 617 #ifdef _WIN64
 618 #if defined(_M_IA64)
 619                         ProcRva = (DWORD)((DWORD_PTR)PLabel - (DWORD_PTR)DosHeader);
 620                         *(PLabel)++ = *ExportFixup->ProcAddress.PLabel;
 621 #elif defined(_M_AMD64)
 622                         ProcRva = (DWORD)((DWORD_PTR)Trampoline - (DWORD_PTR)DosHeader);
 623                         /* mov r11, ExportFixup->ProcAddress */
 624                         *(Trampoline)++ = 0x49;
 625                         *(Trampoline)++ = 0xBB;
 626                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[0];
 627                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[1];
 628                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[2];
 629                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[3];
 630                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[4];
 631                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[5];
 632                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[6];
 633                         *(Trampoline)++ = ExportFixup->ProcAddress.Bytes[7];
 634                         /* jmp r11 */
 635                         *(Trampoline)++ = 0x41;
 636                         *(Trampoline)++ = 0xFF;
 637                         *(Trampoline)++ = 0xE3;
 638 #else
 639 #error Unsupported architecture.
 640 #endif
 641 #else
 642                         ProcRva = (DWORD)(ExportFixup->ProcAddress.DWordPtr - (DWORD_PTR)DosHeader);
 643 #endif
 644                         Address = &Functions[NameOrdinals[i]];
 645                         if (!VirtualProtect(Address, sizeof(DWORD), PAGE_READWRITE, &OldProtect))
 646                                 return E_UNEXPECTED;
 647                         *ExportFixupRva = *Address;
 648                         *Address = ProcRva;
 649                         if (!VirtualProtect(Address, sizeof(DWORD), OldProtect, &OldProtect))
 650                                 return E_UNEXPECTED;
 651                         ExportFixup++;
 652                         if (ExportFixup->Name == NULL) {
 653 #ifdef _WIN64
 654                                 if (!VirtualProtect(Region, ELEMENT_SIZE * EXPORT_FIXUP_COUNT, REGION_PROTECT, &OldProtect))
 655                                         return E_UNEXPECTED;
 656 #endif
 657
 658                                 ExportFixupModuleHandle = ModuleHandle;
 659                                 return S_OK;
 660                         }
 661                         ExportFixupRva++;
 662                 }
 663         }
 664         return E_FAIL;
 665 }
 666
 667 /* Executable images are only mapped by the OS loader. We need to do fixups for native code support. */
 668 STDAPI MonoFixupExe(HMODULE ModuleHandle)
 669 {
 670         IMAGE_DOS_HEADER* DosHeader;
 671         IMAGE_NT_HEADERS* NtHeaders;
 672         DWORD_PTR* Address;
 673         DWORD OldProtect;
 674         DWORD_PTR BaseDiff;
 675
 676         DosHeader = (IMAGE_DOS_HEADER*)ModuleHandle;
 677         if (DosHeader == NULL)
 678                 return E_POINTER;
 679
 680         if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE)
 681                 return E_INVALIDARG;
 682
 683         NtHeaders = (IMAGE_NT_HEADERS*)((DWORD_PTR)DosHeader + DosHeader->e_lfanew);
 684         if (NtHeaders->Signature != IMAGE_NT_SIGNATURE)
 685                 return E_INVALIDARG;
 686
 687         if (NtHeaders->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
 688                 return E_INVALIDARG;
 689
 690         if (NtHeaders->FileHeader.Characteristics & IMAGE_FILE_DLL)
 691                 return S_OK;
 692
 693         if (NtHeaders->OptionalHeader.NumberOfRvaAndSizes > IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR)
 694         {
 695                 IMAGE_DATA_DIRECTORY* CliHeaderDir;
 696                 MonoCLIHeader* CliHeader;
 697
 698                 CliHeaderDir = &NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];
 699                 if (CliHeaderDir->VirtualAddress)
 700                 {
 701                         CliHeader = (MonoCLIHeader*)((DWORD_PTR)DosHeader + CliHeaderDir->VirtualAddress);
 702                         if (CliHeader->ch_flags & CLI_FLAGS_ILONLY)
 703                                 return S_OK;
 704                 }
 705         }
 706
 707         BaseDiff = (DWORD_PTR)DosHeader - NtHeaders->OptionalHeader.ImageBase;
 708         if (BaseDiff != 0)
 709         {
 710                 if (NtHeaders->FileHeader.Characteristics & IMAGE_FILE_RELOCS_STRIPPED)
 711                         return E_FAIL;
 712
 713                 Address = &NtHeaders->OptionalHeader.ImageBase;
 714                 if (!VirtualProtect(Address, sizeof(DWORD_PTR), PAGE_READWRITE, &OldProtect))
 715                         return E_UNEXPECTED;
 716                 *Address = (DWORD_PTR)DosHeader;
 717                 if (!VirtualProtect(Address, sizeof(DWORD_PTR), OldProtect, &OldProtect))
 718                         return E_UNEXPECTED;
 719
 720                 if (NtHeaders->OptionalHeader.NumberOfRvaAndSizes > IMAGE_DIRECTORY_ENTRY_BASERELOC)
 721                 {
 722                         IMAGE_DATA_DIRECTORY* BaseRelocDir;
 723                         IMAGE_BASE_RELOCATION* BaseReloc;
 724                         USHORT* RelocBlock;
 725                         ULONG BaseRelocSize;
 726                         ULONG RelocBlockSize;
 727                         USHORT RelocOffset;
 728                         DWORD_PTR UNALIGNED *RelocFixup;
 729
 730                         BaseRelocDir = &NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
 731                         if (BaseRelocDir->VirtualAddress)
 732                         {
 733                                 BaseReloc = (IMAGE_BASE_RELOCATION*)((DWORD_PTR)DosHeader + BaseRelocDir->VirtualAddress);
 734                                 BaseRelocSize = BaseRelocDir->Size;
 735
 736                                 while (BaseRelocSize)
 737                                 {
 738                                         RelocBlockSize = BaseReloc->SizeOfBlock;
 739
 740                                         if (!RelocBlockSize || BaseRelocSize < RelocBlockSize)
 741                                                 return E_FAIL;
 742
 743                                         BaseRelocSize -= RelocBlockSize;
 744                                         RelocBlock = (USHORT*)((DWORD_PTR)BaseReloc + sizeof(IMAGE_BASE_RELOCATION));
 745                                         RelocBlockSize -= sizeof(IMAGE_BASE_RELOCATION);
 746                                         RelocBlockSize /= sizeof(USHORT);
 747
 748                                         while (RelocBlockSize-- != 0)
 749                                         {
 750                                                 RelocOffset = *RelocBlock & (USHORT)0x0fff;
 751                                                 RelocFixup = (DWORD_PTR*)((DWORD_PTR)DosHeader + BaseReloc->VirtualAddress + RelocOffset);
 752
 753                                                 switch (*RelocBlock >> 12)
 754                                                 {
 755                                                         case IMAGE_REL_BASED_ABSOLUTE:
 756                                                                 break;
 757
 758 #ifdef _WIN64
 759                                                         case IMAGE_REL_BASED_DIR64:
 760 #else
 761                                                         case IMAGE_REL_BASED_HIGHLOW:
 762 #endif
 763                                                                 if (!VirtualProtect(RelocFixup, sizeof(DWORD_PTR), PAGE_EXECUTE_READWRITE, &OldProtect))
 764                                                                         return E_UNEXPECTED;
 765                                                                 *RelocFixup += BaseDiff;
 766                                                                 if (!VirtualProtect(RelocFixup, sizeof(DWORD_PTR), OldProtect, &OldProtect))
 767                                                                         return E_UNEXPECTED;
 768                                                                 break;
 769
 770                                                         default:
 771                                                                 return E_FAIL;
 772                                                 }
 773
 774                                                 RelocBlock++;
 775                                         }
 776                                         BaseReloc = (IMAGE_BASE_RELOCATION*)RelocBlock;
 777                                 }
 778                         }
 779                 }
 780         }
 781
 782         if (NtHeaders->OptionalHeader.NumberOfRvaAndSizes > IMAGE_DIRECTORY_ENTRY_IMPORT)
 783         {
 784                 IMAGE_DATA_DIRECTORY* ImportDir;
 785                 IMAGE_IMPORT_DESCRIPTOR* ImportDesc;
 786                 HMODULE ImportModuleHandle;
 787                 IMAGE_THUNK_DATA* ImportThunkData;
 788                 DWORD_PTR ProcAddress;
 789
 790                 ImportDir = &NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
 791                 if (ImportDir->VirtualAddress != 0)
 792                 {
 793                         ImportDesc = (IMAGE_IMPORT_DESCRIPTOR*)((DWORD_PTR)DosHeader + ImportDir->VirtualAddress);
 794                         while (ImportDesc->Name && ImportDesc->OriginalFirstThunk)
 795                         {
 796                                 ImportModuleHandle = LoadLibraryA((PCSTR)((DWORD_PTR)DosHeader + ImportDesc->Name));
 797                                 if (ImportModuleHandle == NULL)
 798                                         return E_FAIL;
 799
 800                                 ImportThunkData = (IMAGE_THUNK_DATA*)((DWORD_PTR)DosHeader + ImportDesc->OriginalFirstThunk);
 801                                 while (ImportThunkData->u1.Ordinal != 0)
 802                                 {
 803                                         if (IMAGE_SNAP_BY_ORDINAL(ImportThunkData->u1.Ordinal))
 804                                                 ProcAddress = (DWORD_PTR)GetProcAddress(ImportModuleHandle, (LPCSTR)IMAGE_ORDINAL(ImportThunkData->u1.Ordinal));
 805                                         else
 806                                         {
 807                                                 IMAGE_IMPORT_BY_NAME* ImportByName = (IMAGE_IMPORT_BY_NAME*)((DWORD_PTR)DosHeader + ImportThunkData->u1.AddressOfData);
 808                                                 ProcAddress = (DWORD_PTR)GetProcAddress(ImportModuleHandle, ImportByName->Name);
 809                                         }
 810                                         if (ProcAddress == 0)
 811                                                 return E_FAIL;
 812                                         Address = (DWORD_PTR*)((DWORD_PTR)ImportThunkData - ImportDesc->OriginalFirstThunk + ImportDesc->FirstThunk);
 813                                         if (!VirtualProtect(Address, sizeof(DWORD_PTR), PAGE_READWRITE, &OldProtect))
 814                                                 return E_UNEXPECTED;
 815                                         *Address = ProcAddress;
 816                                         if (!VirtualProtect(Address, sizeof(DWORD_PTR), OldProtect, &OldProtect))
 817                                                 return E_UNEXPECTED;
 818                                         ImportThunkData++;
 819                                 }
 820
 821                                 ImportDesc++;
 822                         }
 823                 }
 824         }
 825
 826         return S_OK;
 827 }
 828
 829 static void
 830 mono_set_act_ctx (const char* file_name)
 831 {
 832         typedef HANDLE (WINAPI* CREATEACTCTXW_PROC) (PCACTCTXW pActCtx);
 833         typedef BOOL (WINAPI* ACTIVATEACTCTX_PROC) (HANDLE hActCtx, ULONG_PTR* lpCookie);
 834
 835         HMODULE kernel32_handle;
 836         CREATEACTCTXW_PROC CreateActCtx_proc;
 837         ACTIVATEACTCTX_PROC ActivateActCtx_proc;
 838         gchar* full_path;
 839         gunichar2* full_path_utf16;
 840         gchar* dir_name;
 841         gunichar2* dir_name_utf16;
 842         gchar* base_name;
 843         gunichar2* base_name_utf16;
 844         ACTCTX act_ctx;
 845         HANDLE handle;
 846         ULONG_PTR cookie;
 847
 848         kernel32_handle = GetModuleHandle (L"kernel32.dll");
 849         if (!kernel32_handle)
 850                 return;
 851         CreateActCtx_proc = (CREATEACTCTXW_PROC) GetProcAddress (kernel32_handle, "CreateActCtxW");
 852         if (!CreateActCtx_proc)
 853                 return;
 854         ActivateActCtx_proc = (ACTIVATEACTCTX_PROC) GetProcAddress (kernel32_handle, "ActivateActCtx");
 855         if (!ActivateActCtx_proc)
 856                 return;
 857
 858         full_path = mono_path_canonicalize (file_name);
 859         full_path_utf16 = g_utf8_to_utf16 (full_path, -1, NULL, NULL, NULL);
 860         dir_name = g_path_get_dirname (full_path);
 861         dir_name_utf16 = g_utf8_to_utf16 (dir_name, -1, NULL, NULL, NULL);
 862         base_name = g_path_get_basename (full_path);
 863         base_name_utf16 = g_utf8_to_utf16 (base_name, -1, NULL, NULL, NULL);
 864         g_free (base_name);
 865         g_free (dir_name);
 866         g_free (full_path);
 867
 868         memset (&act_ctx, 0, sizeof (ACTCTX));
 869         act_ctx.cbSize = sizeof (ACTCTX);
 870         act_ctx.dwFlags = ACTCTX_FLAG_SET_PROCESS_DEFAULT | ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID | ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_APPLICATION_NAME_VALID;
 871         act_ctx.lpSource = full_path_utf16;
 872         act_ctx.lpAssemblyDirectory = dir_name_utf16;
 873         act_ctx.lpResourceName = MAKEINTRESOURCE (CREATEPROCESS_MANIFEST_RESOURCE_ID);
 874         act_ctx.lpApplicationName = base_name_utf16;
 875
 876         handle = CreateActCtx_proc (&act_ctx);
 877         if (handle == INVALID_HANDLE_VALUE && GetLastError () == ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET) {
 878                 act_ctx.dwFlags &= ~ACTCTX_FLAG_SET_PROCESS_DEFAULT;
 879                 handle = CreateActCtx_proc (&act_ctx);
 880         }
 881
 882         g_free (base_name_utf16);
 883         g_free (dir_name_utf16);
 884         g_free (full_path_utf16);
 885
 886         if (handle != INVALID_HANDLE_VALUE)
 887                 ActivateActCtx_proc (handle, &cookie);
 888 }
 889
 890 void
 891 mono_load_coree (const char* exe_file_name)
 892 {
 893         HMODULE module_handle;
 894         gunichar2* file_name;
 895         UINT required_size;
 896         UINT size;
 897
 898         if (coree_module_handle)
 899                 return;
 900
 901         if (!init_from_coree && exe_file_name)
 902                 mono_set_act_ctx (exe_file_name);
 903
 904         /* ntdll.dll loads mscoree.dll from the system32 directory. */
 905         required_size = GetSystemDirectory (NULL, 0);
 906         file_name = g_new (gunichar2, required_size + 12);
 907         size = GetSystemDirectory (file_name, required_size);
 908         g_assert (size < required_size);
 909         if (file_name [size - 1] != L'\\')
 910                 file_name [size++] = L'\\';
 911         memcpy (&file_name [size], L"mscoree.dll", 12 * sizeof (gunichar2));
 912
 913         module_handle = LoadLibrary (file_name);
 914         g_free (file_name);
 915
 916         if (module_handle && !SUCCEEDED (MonoFixupCorEE (module_handle))) {
 917                 FreeLibrary (module_handle);
 918                 module_handle = NULL;
 919         }
 920
 921         coree_module_handle = module_handle;
 922 }
 923
 924 void
 925 mono_fixup_exe_image (MonoImage* image)
 926 {
 927         if (!init_from_coree && image && image->is_module_handle)
 928                 MonoFixupExe ((HMODULE) image->raw_data);
 929 }
 930
 931 #endif /* HOST_WIN32 */