int coreclr_execute_assembly( void* hostHandle, unsigned int domainId, int argc, const char** argv, const char* managedAssemblyPath, unsigned int* exitCode) { if (exitCode == NULL) { return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } *exitCode = -1; ICLRRuntimeHost2* host = reinterpret_cast<ICLRRuntimeHost2*>(hostHandle); ConstWStringArrayHolder argvW; argvW.Set(StringArrayToUnicode(argc, argv), argc); ConstWStringHolder managedAssemblyPathW = StringToUnicode(managedAssemblyPath); HRESULT hr = host->ExecuteAssembly(domainId, managedAssemblyPathW, argc, argvW, (DWORD *)exitCode); IfFailRet(hr); return hr; }
int coreclr_create_delegate( void* hostHandle, unsigned int domainId, const char* entryPointAssemblyName, const char* entryPointTypeName, const char* entryPointMethodName, void** delegate) { ICLRRuntimeHost2* host = reinterpret_cast<ICLRRuntimeHost2*>(hostHandle); ConstWStringHolder entryPointAssemblyNameW = StringToUnicode(entryPointAssemblyName); ConstWStringHolder entryPointTypeNameW = StringToUnicode(entryPointTypeName); ConstWStringHolder entryPointMethodNameW = StringToUnicode(entryPointMethodName); HRESULT hr = host->CreateDelegate( domainId, entryPointAssemblyNameW, entryPointTypeNameW, entryPointMethodNameW, (INT_PTR*)delegate); return hr; }
// One large main method to keep this sample streamlined. // // This function demonstrates how to start the .NET Core runtime, // create an AppDomain, and execute managed code. // // It is meant as an educational sample, so not all error paths are checked, // cross-platform functionality is not yet implemented, and some design // decisions have been made to emphasize readability over efficiency. int wmain(int argc, wchar_t* argv[]) { printf("Sample CoreCLR Host\n\n"); // // STEP 1: Get the app to be run from the command line // if (argc < 2) { printf("ERROR - Specify exe to run as the app's first parameter"); return -1; } // <Snippet1> // The managed application to run should be the first command-line parameter. // Subsequent command line parameters will be passed to the managed app later in this host. wchar_t targetApp[MAX_PATH]; GetFullPathNameW(argv[1], MAX_PATH, targetApp, NULL); // </Snippet1> // Also note the directory the target app is in, as it will be referenced later. // The directory is determined by simply truncating the target app's full path // at the last path delimiter (\) wchar_t targetAppPath[MAX_PATH]; wcscpy_s(targetAppPath, targetApp); size_t i = wcslen(targetAppPath - 1); while (i >= 0 && targetAppPath[i] != L'\\') i--; targetAppPath[i] = L'\0'; // // STEP 2: Find and load CoreCLR.dll // HMODULE coreCLRModule; // Look in %CORE_ROOT% wchar_t coreRoot[MAX_PATH]; size_t outSize; _wgetenv_s(&outSize, coreRoot, MAX_PATH, L"CORE_ROOT"); coreCLRModule = LoadCoreCLR(coreRoot); // If CoreCLR.dll wasn't in %CORE_ROOT%, look next to the target app if (!coreCLRModule) { wcscpy_s(coreRoot, MAX_PATH, targetAppPath); coreCLRModule = LoadCoreCLR(coreRoot); } // If CoreCLR.dll wasn't in %CORE_ROOT% or next to the app, // look in the common 1.1.0 install directory if (!coreCLRModule) { ::ExpandEnvironmentStringsW(coreCLRInstallDirectory, coreRoot, MAX_PATH); coreCLRModule = LoadCoreCLR(coreRoot); } if (!coreCLRModule) { printf("ERROR - CoreCLR.dll could not be found"); return -1; } else { wprintf(L"CoreCLR loaded from %s\n", coreRoot); } // // STEP 3: Get ICLRRuntimeHost2 instance // // <Snippet3> ICLRRuntimeHost2* runtimeHost; FnGetCLRRuntimeHost pfnGetCLRRuntimeHost = (FnGetCLRRuntimeHost)::GetProcAddress(coreCLRModule, "GetCLRRuntimeHost"); if (!pfnGetCLRRuntimeHost) { printf("ERROR - GetCLRRuntimeHost not found"); return -1; } // Get the hosting interface HRESULT hr = pfnGetCLRRuntimeHost(IID_ICLRRuntimeHost2, (IUnknown**)&runtimeHost); // </Snippet3> if (FAILED(hr)) { printf("ERROR - Failed to get ICLRRuntimeHost2 instance.\nError code:%x\n", hr); return -1; } // // STEP 4: Set desired startup flags and start the CLR // // <Snippet4> hr = runtimeHost->SetStartupFlags( // These startup flags control runtime-wide behaviors. // A complete list of STARTUP_FLAGS can be found in mscoree.h, // but some of the more common ones are listed below. static_cast<STARTUP_FLAGS>( // STARTUP_FLAGS::STARTUP_SERVER_GC | // Use server GC // STARTUP_FLAGS::STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN | // Maximize domain-neutral loading // STARTUP_FLAGS::STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST | // Domain-neutral loading for strongly-named assemblies STARTUP_FLAGS::STARTUP_CONCURRENT_GC | // Use concurrent GC STARTUP_FLAGS::STARTUP_SINGLE_APPDOMAIN | // All code executes in the default AppDomain // (required to use the runtimeHost->ExecuteAssembly helper function) STARTUP_FLAGS::STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN // Prevents domain-neutral loading ) ); // </Snippet4> if (FAILED(hr)) { printf("ERROR - Failed to set startup flags.\nError code:%x\n", hr); return -1; } // Starting the runtime will initialize the JIT, GC, loader, etc. hr = runtimeHost->Start(); if (FAILED(hr)) { printf("ERROR - Failed to start the runtime.\nError code:%x\n", hr); return -1; } else { printf("Runtime started\n"); } // // STEP 5: Prepare properties for the AppDomain we will create // // Flags // <Snippet5> int appDomainFlags = // APPDOMAIN_FORCE_TRIVIAL_WAIT_OPERATIONS | // Do not pump messages during wait // APPDOMAIN_SECURITY_SANDBOXED | // Causes assemblies not from the TPA list to be loaded as partially trusted APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS | // Enable platform-specific assemblies to run APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP | // Allow PInvoking from non-TPA assemblies APPDOMAIN_DISABLE_TRANSPARENCY_ENFORCEMENT; // Entirely disables transparency checks // </Snippet5> // <Snippet6> // TRUSTED_PLATFORM_ASSEMBLIES // "Trusted Platform Assemblies" are prioritized by the loader and always loaded with full trust. // A common pattern is to include any assemblies next to CoreCLR.dll as platform assemblies. // More sophisticated hosts may also include their own Framework extensions (such as AppDomain managers) // in this list. int tpaSize = 100 * MAX_PATH; // Starting size for our TPA (Trusted Platform Assemblies) list wchar_t* trustedPlatformAssemblies = new wchar_t[tpaSize]; trustedPlatformAssemblies[0] = L'\0'; // Extensions to probe for when finding TPA list files wchar_t *tpaExtensions[] = { L"*.dll", L"*.exe", L"*.winmd" }; // Probe next to CoreCLR.dll for any files matching the extensions from tpaExtensions and // add them to the TPA list. In a real host, this would likely be extracted into a separate function // and perhaps also run on other directories of interest. for (int i = 0; i < _countof(tpaExtensions); i++) { // Construct the file name search pattern wchar_t searchPath[MAX_PATH]; wcscpy_s(searchPath, MAX_PATH, coreRoot); wcscat_s(searchPath, MAX_PATH, L"\\"); wcscat_s(searchPath, MAX_PATH, tpaExtensions[i]); // Find files matching the search pattern WIN32_FIND_DATAW findData; HANDLE fileHandle = FindFirstFileW(searchPath, &findData); if (fileHandle != INVALID_HANDLE_VALUE) { do { // Construct the full path of the trusted assembly wchar_t pathToAdd[MAX_PATH]; wcscpy_s(pathToAdd, MAX_PATH, coreRoot); wcscat_s(pathToAdd, MAX_PATH, L"\\"); wcscat_s(pathToAdd, MAX_PATH, findData.cFileName); // Check to see if TPA list needs expanded if (wcslen(pathToAdd) + (3) + wcslen(trustedPlatformAssemblies) >= tpaSize) { // Expand, if needed tpaSize *= 2; wchar_t* newTPAList = new wchar_t[tpaSize]; wcscpy_s(newTPAList, tpaSize, trustedPlatformAssemblies); trustedPlatformAssemblies = newTPAList; } // Add the assembly to the list and delimited with a semi-colon wcscat_s(trustedPlatformAssemblies, tpaSize, pathToAdd); wcscat_s(trustedPlatformAssemblies, tpaSize, L";"); // Note that the CLR does not guarantee which assembly will be loaded if an assembly // is in the TPA list multiple times (perhaps from different paths or perhaps with different NI/NI.dll // extensions. Therefore, a real host should probably add items to the list in priority order and only // add a file if it's not already present on the list. // // For this simple sample, though, and because we're only loading TPA assemblies from a single path, // we can ignore that complication. } while (FindNextFileW(fileHandle, &findData)); FindClose(fileHandle); } } // APP_PATHS // App paths are directories to probe in for assemblies which are not one of the well-known Framework assemblies // included in the TPA list. // // For this simple sample, we just include the directory the target application is in. // More complex hosts may want to also check the current working directory or other // locations known to contain application assets. wchar_t appPaths[MAX_PATH * 50]; // Just use the targetApp provided by the user and remove the file name wcscpy_s(appPaths, targetAppPath); // APP_NI_PATHS // App (NI) paths are the paths that will be probed for native images not found on the TPA list. // It will typically be similar to the app paths. // For this sample, we probe next to the app and in a hypothetical directory of the same name with 'NI' suffixed to the end. wchar_t appNiPaths[MAX_PATH * 50]; wcscpy_s(appNiPaths, targetAppPath); wcscat_s(appNiPaths, MAX_PATH * 50, L";"); wcscat_s(appNiPaths, MAX_PATH * 50, targetAppPath); wcscat_s(appNiPaths, MAX_PATH * 50, L"NI"); // NATIVE_DLL_SEARCH_DIRECTORIES // Native dll search directories are paths that the runtime will probe for native DLLs called via PInvoke wchar_t nativeDllSearchDirectories[MAX_PATH * 50]; wcscpy_s(nativeDllSearchDirectories, appPaths); wcscat_s(nativeDllSearchDirectories, MAX_PATH * 50, L";"); wcscat_s(nativeDllSearchDirectories, MAX_PATH * 50, coreRoot); // PLATFORM_RESOURCE_ROOTS // Platform resource roots are paths to probe in for resource assemblies (in culture-specific sub-directories) wchar_t platformResourceRoots[MAX_PATH * 50]; wcscpy_s(platformResourceRoots, appPaths); // AppDomainCompatSwitch // Specifies compatibility behavior for the app domain. This indicates which compatibility // quirks to apply if an assembly doesn't have an explicit Target Framework Moniker. If a TFM is // present on an assembly, the runtime will always attempt to use quirks appropriate to the version // of the TFM. // // Typically the latest behavior is desired, but some hosts may want to default to older Silverlight // or Windows Phone behaviors for compatibility reasons. wchar_t* appDomainCompatSwitch = L"UseLatestBehaviorWhenTFMNotSpecified"; // </Snippet6> // // STEP 6: Create the AppDomain // // <Snippet7> DWORD domainId; // Setup key/value pairs for AppDomain properties const wchar_t* propertyKeys[] = { L"TRUSTED_PLATFORM_ASSEMBLIES", L"APP_PATHS", L"APP_NI_PATHS", L"NATIVE_DLL_SEARCH_DIRECTORIES", L"PLATFORM_RESOURCE_ROOTS", L"AppDomainCompatSwitch" }; // Property values which were constructed in step 5 const wchar_t* propertyValues[] = { trustedPlatformAssemblies, appPaths, appNiPaths, nativeDllSearchDirectories, platformResourceRoots, appDomainCompatSwitch }; // Create the AppDomain hr = runtimeHost->CreateAppDomainWithManager( L"Sample Host AppDomain", // Friendly AD name appDomainFlags, NULL, // Optional AppDomain manager assembly name NULL, // Optional AppDomain manager type (including namespace) sizeof(propertyKeys)/sizeof(wchar_t*), propertyKeys, propertyValues, &domainId); // </Snippet7> if (FAILED(hr)) { printf("ERROR - Failed to create AppDomain.\nError code:%x\n", hr); return -1; } else { printf("AppDomain %d created\n\n", domainId); } // // STEP 7: Run managed code // // ExecuteAssembly will load a managed assembly and execute its entry point. wprintf(L"Executing %s...\n\n", targetApp); // <Snippet8> DWORD exitCode = -1; hr = runtimeHost->ExecuteAssembly(domainId, targetApp, argc - 1, (LPCWSTR*)(argc > 1 ? &argv[1] : NULL), &exitCode); // </Snippet8> if (FAILED(hr)) { wprintf(L"ERROR - Failed to execute %s.\nError code:%x\n", targetApp, hr); return -1; } // Alternatively, to start managed code execution with a method other than an assembly's entrypoint, // runtimeHost->CreateDelegate can be used to create a pointer to an arbitrary static managed method // which can then be executed directly or via runtimeHost->ExecuteInAppDomain. // // void *pfnDelegate = NULL; // hr = runtimeHost->CreateDelegate( // domainId, // L"HW, Version=1.0.0.0, Culture=neutral", // Target managed assembly // L"ConsoleApplication.Program", // Target managed type // L"Main", // Target entry point (static method) // (INT_PTR*)&pfnDelegate); // if (FAILED(hr)) // { // printf("ERROR - Failed to create delegate.\nError code:%x\n", hr); // return -1; // } // ((MainMethodFp*)pfnDelegate)(NULL); // // STEP 8: Clean up // // <Snippet9> runtimeHost->UnloadAppDomain(domainId, true /* Wait until unload complete */); runtimeHost->Stop(); runtimeHost->Release(); // </Snippet9> printf("\nDone\n"); return exitCode; }
extern "C" __declspec(dllexport) HRESULT __stdcall CallApplicationMain(PCALL_APPLICATION_MAIN_DATA data) { HRESULT hr = S_OK; errno_t errno = 0; FnGetCLRRuntimeHost pfnGetCLRRuntimeHost = nullptr; ICLRRuntimeHost2* pCLRRuntimeHost = nullptr; TCHAR szCurrentDirectory[MAX_PATH]; TCHAR szCoreClrDirectory[MAX_PATH]; TCHAR lpCoreClrModulePath[MAX_PATH]; size_t cchTrustedPlatformAssemblies = 0; LPWSTR pwszTrustedPlatformAssemblies = nullptr; Win32KDisable(); if (data->runtimeDirectory) { errno = wcscpy_s(szCurrentDirectory, data->runtimeDirectory); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); } else { GetModuleDirectory(NULL, szCurrentDirectory); } HMODULE hCoreCLRModule = LoadCoreClr(); if (!hCoreCLRModule) { printf_s("Failed to locate coreclr.dll.\n"); return E_FAIL; } // Get the path to the module DWORD dwCoreClrModulePathSize = GetModuleFileName(hCoreCLRModule, lpCoreClrModulePath, MAX_PATH); lpCoreClrModulePath[dwCoreClrModulePathSize] = '\0'; GetModuleDirectory(hCoreCLRModule, szCoreClrDirectory); HMODULE ignoreModule; // Pin the module - CoreCLR.dll does not support being unloaded. if (!::GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN, lpCoreClrModulePath, &ignoreModule)) { printf_s("Failed to pin coreclr.dll.\n"); return E_FAIL; } pfnGetCLRRuntimeHost = (FnGetCLRRuntimeHost)::GetProcAddress(hCoreCLRModule, "GetCLRRuntimeHost"); if (!pfnGetCLRRuntimeHost) { printf_s("Failed to find export GetCLRRuntimeHost.\n"); return E_FAIL; } hr = pfnGetCLRRuntimeHost(IID_ICLRRuntimeHost2, (IUnknown**)&pCLRRuntimeHost); if (FAILED(hr)) { printf_s("Failed to get IID_ICLRRuntimeHost2.\n"); return hr; } STARTUP_FLAGS dwStartupFlags = (STARTUP_FLAGS)( STARTUP_FLAGS::STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN | STARTUP_FLAGS::STARTUP_SINGLE_APPDOMAIN | STARTUP_FLAGS::STARTUP_SERVER_GC ); pCLRRuntimeHost->SetStartupFlags(dwStartupFlags); // Authenticate with either CORECLR_HOST_AUTHENTICATION_KEY or CORECLR_HOST_AUTHENTICATION_KEY_NONGEN hr = pCLRRuntimeHost->Authenticate(CORECLR_HOST_AUTHENTICATION_KEY); if (FAILED(hr)) { printf_s("Failed to Authenticate().\n"); return hr; } hr = pCLRRuntimeHost->Start(); if (FAILED(hr)) { printf_s("Failed to Start().\n"); return hr; } const wchar_t* property_keys[] = { // Allowed property names: // APPBASE // - The base path of the application from which the exe and other assemblies will be loaded L"APPBASE", // // TRUSTED_PLATFORM_ASSEMBLIES // - The list of complete paths to each of the fully trusted assemblies L"TRUSTED_PLATFORM_ASSEMBLIES", // // APP_PATHS // - The list of paths which will be probed by the assembly loader L"APP_PATHS", // // APP_NI_PATHS // - The list of additional paths that the assembly loader will probe for ngen images // // NATIVE_DLL_SEARCH_DIRECTORIES // - The list of paths that will be probed for native DLLs called by PInvoke // }; cchTrustedPlatformAssemblies = TRUSTED_PLATFORM_ASSEMBLIES_STRING_BUFFER_SIZE_CCH; pwszTrustedPlatformAssemblies = (LPWSTR)calloc(cchTrustedPlatformAssemblies+1, sizeof(WCHAR)); if (pwszTrustedPlatformAssemblies == NULL) { goto Finished; } pwszTrustedPlatformAssemblies[0] = L'\0'; // Try native images first if (!GetTrustedPlatformAssembliesList(szCoreClrDirectory, true, pwszTrustedPlatformAssemblies, cchTrustedPlatformAssemblies)) { if (!GetTrustedPlatformAssembliesList(szCoreClrDirectory, false, pwszTrustedPlatformAssemblies, cchTrustedPlatformAssemblies)) { printf_s("Failed to find files in the coreclr directory\n"); return E_FAIL; } } // Add the assembly containing the app domain manager to the trusted list errno = wcscat_s(pwszTrustedPlatformAssemblies, cchTrustedPlatformAssemblies, szCurrentDirectory); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); errno = wcscat_s(pwszTrustedPlatformAssemblies, cchTrustedPlatformAssemblies, L"kre.coreclr.managed.dll"); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); //wstring appPaths(szCurrentDirectory); WCHAR wszAppPaths[MAX_PATH]; wszAppPaths[0] = L'\0'; errno = wcscat_s(wszAppPaths, _countof(wszAppPaths), szCurrentDirectory); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); errno = wcscat_s(wszAppPaths, _countof(wszAppPaths), L";"); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); errno = wcscat_s(wszAppPaths, _countof(wszAppPaths), szCoreClrDirectory); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); errno = wcscat_s(wszAppPaths, _countof(wszAppPaths), L";"); CHECK_RETURN_VALUE_FAIL_EXIT_VIA_FINISHED(errno); const wchar_t* property_values[] = { // APPBASE data->applicationBase, // TRUSTED_PLATFORM_ASSEMBLIES pwszTrustedPlatformAssemblies, // APP_PATHS wszAppPaths, }; DWORD domainId; DWORD dwFlagsAppDomain = APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS | APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP; LPCWSTR szAssemblyName = L"kre.coreclr.managed, Version=0.1.0.0"; LPCWSTR szEntryPointTypeName = L"DomainManager"; LPCWSTR szMainMethodName = L"Execute"; int nprops = sizeof(property_keys) / sizeof(wchar_t*); hr = pCLRRuntimeHost->CreateAppDomainWithManager( L"kre.coreclr.managed", dwFlagsAppDomain, NULL, NULL, nprops, property_keys, property_values, &domainId); if (FAILED(hr)) { wprintf_s(L"TPA %d %S\n", wcslen(pwszTrustedPlatformAssemblies), pwszTrustedPlatformAssemblies); wprintf_s(L"AppPaths %S\n", wszAppPaths); printf_s("Failed to create app domain (%x).\n", hr); return hr; } HostMain pHostMain; hr = pCLRRuntimeHost->CreateDelegate( domainId, szAssemblyName, szEntryPointTypeName, szMainMethodName, (INT_PTR*)&pHostMain); if (FAILED(hr)) { printf_s("Failed to create main delegate (%x).\n", hr); return hr; } SetEnvironmentVariable(L"KRE_FRAMEWORK", L"aspnetcore50"); // Call main data->exitcode = pHostMain(data->argc, data->argv); pCLRRuntimeHost->UnloadAppDomain(domainId, true); pCLRRuntimeHost->Stop(); Finished: if (pwszTrustedPlatformAssemblies != NULL) { free(pwszTrustedPlatformAssemblies); pwszTrustedPlatformAssemblies = NULL; } if (FAILED(hr)) { return hr; } else { return S_OK; } }
bool TryRun(const int argc, const wchar_t* argv[], Logger &log, const bool verbose, const bool waitForDebugger, DWORD &exitCode, wchar_t* programPath) { // Assume failure exitCode = -1; HostEnvironment hostEnvironment(&log); wchar_t appPath[MAX_PATH] = W(""); wchar_t appNiPath[MAX_PATH * 2] = W(""); wchar_t managedAssemblyFullName[MAX_PATH] = W(""); wchar_t* filePart = NULL; if (!::GetFullPathName(programPath, MAX_PATH, appPath, &filePart)) { log << W("Failed to get full path: ") << programPath << Logger::endl; log << W("Error code: ") << GetLastError() << Logger::endl; return false; } wcscpy_s(managedAssemblyFullName, appPath); *(filePart) = W('\0'); log << W("Loading: ") << managedAssemblyFullName << Logger::endl; wcscpy_s(appNiPath, appPath); wcscat_s(appNiPath, MAX_PATH * 2, W(";")); wcscat_s(appNiPath, MAX_PATH * 2, appPath); // Construct native search directory paths wchar_t nativeDllSearchDirs[MAX_PATH * 3]; wcscpy_s(nativeDllSearchDirs, appPath); wchar_t coreLibraries[MAX_PATH]; size_t outSize; if (_wgetenv_s(&outSize, coreLibraries, MAX_PATH, W("CORE_LIBRARIES")) == 0 && outSize > 0) { wcscat_s(nativeDllSearchDirs, MAX_PATH * 3, W(";")); wcscat_s(nativeDllSearchDirs, MAX_PATH * 3, coreLibraries); } wcscat_s(nativeDllSearchDirs, MAX_PATH * 3, W(";")); wcscat_s(nativeDllSearchDirs, MAX_PATH * 3, hostEnvironment.m_coreCLRDirectoryPath); // Start the CoreCLR ICLRRuntimeHost2 *host = hostEnvironment.GetCLRRuntimeHost(); if (!host) { return false; } HRESULT hr; log << W("Setting ICLRRuntimeHost2 startup flags") << Logger::endl; // Default startup flags hr = host->SetStartupFlags((STARTUP_FLAGS) (STARTUP_FLAGS::STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN | STARTUP_FLAGS::STARTUP_SINGLE_APPDOMAIN)); if (FAILED(hr)) { log << W("Failed to set startup flags. ERRORCODE: ") << hr << Logger::endl; return false; } log << W("Starting ICLRRuntimeHost2") << Logger::endl; hr = host->Start(); if (FAILED(hr)) { log << W("Failed to start CoreCLR. ERRORCODE: ") << hr << Logger:: endl; return false; } //------------------------------------------------------------- // Create an AppDomain // Allowed property names: // APPBASE // - The base path of the application from which the exe and other assemblies will be loaded // // TRUSTED_PLATFORM_ASSEMBLIES // - The list of complete paths to each of the fully trusted assemblies // // APP_PATHS // - The list of paths which will be probed by the assembly loader // // APP_NI_PATHS // - The list of additional paths that the assembly loader will probe for ngen images // // NATIVE_DLL_SEARCH_DIRECTORIES // - The list of paths that will be probed for native DLLs called by PInvoke // const wchar_t *property_keys[] = { W("TRUSTED_PLATFORM_ASSEMBLIES"), W("APP_PATHS"), W("APP_NI_PATHS"), W("NATIVE_DLL_SEARCH_DIRECTORIES") W("AppDomainCompatSwitch"), }; const wchar_t *property_values[] = { // TRUSTED_PLATFORM_ASSEMBLIES hostEnvironment.GetTpaList(), // APP_PATHS appPath, // APP_NI_PATHS appNiPath, // NATIVE_DLL_SEARCH_DIRECTORIES nativeDllSearchDirs, }; log << W("Creating an AppDomain") << Logger::endl; log << W("TRUSTED_PLATFORM_ASSEMBLIES=") << property_values[0] << Logger::endl; log << W("APP_PATHS=") << property_values[1] << Logger::endl; log << W("APP_NI_PATHS=") << property_values[2] << Logger::endl; log << W("NATIVE_DLL_SEARCH_DIRECTORIES=") << property_values[3] << Logger::endl; DWORD domainId; hr = host->CreateAppDomainWithManager( hostEnvironment.GetHostExeName(), // The friendly name of the AppDomain // Flags: // APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS // - By default CoreCLR only allows platform neutral assembly to be run. To allow // assemblies marked as platform specific, include this flag // // APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP // - Allows sandboxed applications to make P/Invoke calls and use COM interop // // APPDOMAIN_SECURITY_SANDBOXED // - Enables sandboxing. If not set, the app is considered full trust // // APPDOMAIN_IGNORE_UNHANDLED_EXCEPTION // - Prevents the application from being torn down if a managed exception is unhandled // APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS | APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP | APPDOMAIN_DISABLE_TRANSPARENCY_ENFORCEMENT, NULL, // Name of the assembly that contains the AppDomainManager implementation NULL, // The AppDomainManager implementation type name sizeof(property_keys)/sizeof(wchar_t*), // The number of properties property_keys, property_values, &domainId); if (FAILED(hr)) { log << W("Failed call to CreateAppDomainWithManager. ERRORCODE: ") << hr << Logger::endl; return false; } if(waitForDebugger) { if(!IsDebuggerPresent()) { log << W("Waiting for the debugger to attach. Press any key to continue ...") << Logger::endl; getchar(); if (IsDebuggerPresent()) { log << "Debugger is attached." << Logger::endl; } else { log << "Debugger failed to attach." << Logger::endl; } } } hr = host->ExecuteAssembly(domainId, managedAssemblyFullName, argc, (argc)?&(argv[0]):NULL, &exitCode); if (FAILED(hr)) { log << W("Failed call to ExecuteAssembly. ERRORCODE: ") << hr << Logger::endl; return false; } log << W("App exit value = ") << exitCode << Logger::endl; //------------------------------------------------------------- // Unload the AppDomain log << W("Unloading the AppDomain") << Logger::endl; hr = host->UnloadAppDomain( domainId, true); // Wait until done if (FAILED(hr)) { log << W("Failed to unload the AppDomain. ERRORCODE: ") << hr << Logger::endl; return false; } //------------------------------------------------------------- // Stop the host log << W("Stopping the host") << Logger::endl; hr = host->Stop(); if (FAILED(hr)) { log << W("Failed to stop the host. ERRORCODE: ") << hr << Logger::endl; return false; } //------------------------------------------------------------- // Release the reference to the host log << W("Releasing ICLRRuntimeHost2") << Logger::endl; host->Release(); return true; }
extern "C" __declspec(dllexport) bool __stdcall CallApplicationMain(PCALL_APPLICATION_MAIN_DATA data) { HRESULT hr = S_OK; FnGetCLRRuntimeHost pfnGetCLRRuntimeHost = nullptr; ICLRRuntimeHost2* pCLRRuntimeHost = nullptr; TCHAR szCurrentDirectory[MAX_PATH]; TCHAR szCoreClrDirectory[MAX_PATH]; TCHAR lpCoreClrModulePath[MAX_PATH]; GetModuleDirectory(NULL, szCurrentDirectory); HMODULE hCoreCLRModule = LoadCoreClr(); if (!hCoreCLRModule) { printf_s("Failed to locate coreclr.dll.\n"); return false; } // Get the path to the module DWORD dwCoreClrModulePathSize = GetModuleFileName(hCoreCLRModule, lpCoreClrModulePath, MAX_PATH); lpCoreClrModulePath[dwCoreClrModulePathSize] = '\0'; GetModuleDirectory(hCoreCLRModule, szCoreClrDirectory); HMODULE ignoreModule; // Pin the module - CoreCLR.dll does not support being unloaded. if (!::GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN, lpCoreClrModulePath, &ignoreModule)) { printf_s("Failed to pin coreclr.dll.\n"); return false; } pfnGetCLRRuntimeHost = (FnGetCLRRuntimeHost)::GetProcAddress(hCoreCLRModule, "GetCLRRuntimeHost"); if (!pfnGetCLRRuntimeHost) { printf_s("Failed to find export GetCLRRuntimeHost.\n"); return false; } hr = pfnGetCLRRuntimeHost(IID_ICLRRuntimeHost2, (IUnknown**)&pCLRRuntimeHost); if (FAILED(hr)) { printf_s("Failed to get IID_ICLRRuntimeHost2.\n"); return false; } STARTUP_FLAGS dwStartupFlags = (STARTUP_FLAGS)( STARTUP_FLAGS::STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN | STARTUP_FLAGS::STARTUP_SINGLE_APPDOMAIN ); pCLRRuntimeHost->SetStartupFlags(dwStartupFlags); // Authenticate with either CORECLR_HOST_AUTHENTICATION_KEY or CORECLR_HOST_AUTHENTICATION_KEY_NONGEN hr = pCLRRuntimeHost->Authenticate(CORECLR_HOST_AUTHENTICATION_KEY); if (FAILED(hr)) { printf_s("Failed to Authenticate().\n"); return false; } hr = pCLRRuntimeHost->Start(); if (FAILED(hr)) { printf_s("Failed to Start().\n"); return false; } const wchar_t* property_keys[] = { // Allowed property names: // APPBASE // - The base path of the application from which the exe and other assemblies will be loaded L"APPBASE", // // TRUSTED_PLATFORM_ASSEMBLIES // - The list of complete paths to each of the fully trusted assemblies L"TRUSTED_PLATFORM_ASSEMBLIES", // // APP_PATHS // - The list of paths which will be probed by the assembly loader L"APP_PATHS", // // APP_NI_PATHS // - The list of additional paths that the assembly loader will probe for ngen images // // NATIVE_DLL_SEARCH_DIRECTORIES // - The list of paths that will be probed for native DLLs called by PInvoke // }; wstring trustedPlatformAssemblies(L""); // Enumerate the core clr directory and add each .dll or .ni.dll to the list of trusted assemblies wstring pattern(szCoreClrDirectory); pattern += L"*.dll"; WIN32_FIND_DATA ffd; HANDLE findHandle = FindFirstFile(pattern.c_str(), &ffd); if (INVALID_HANDLE_VALUE == findHandle) { printf_s("Failed to find files in the coreclr directory\n"); return -1; } do { if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // Skip directories } else { trustedPlatformAssemblies += szCoreClrDirectory; trustedPlatformAssemblies += ffd.cFileName; trustedPlatformAssemblies += L";"; } } while (FindNextFile(findHandle, &ffd) != 0); // Add the assembly containing the app domain manager to the trusted list trustedPlatformAssemblies += szCurrentDirectory; trustedPlatformAssemblies += L"klr.core45.managed.dll"; wstring appPaths(szCurrentDirectory); appPaths += L";"; appPaths += szCoreClrDirectory; const wchar_t* property_values[] = { // APPBASE szCurrentDirectory, // TODO: Allow overriding this // TRUSTED_PLATFORM_ASSEMBLIES trustedPlatformAssemblies.c_str(), // APP_PATHS appPaths.c_str(), }; DWORD domainId; DWORD dwFlagsAppDomain = APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS | APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP | APPDOMAIN_ENABLE_ASSEMBLY_LOADFILE; LPCWSTR szAssemblyName = L"klr.core45.managed, Version=1.0.0.0"; LPCWSTR szDomainManagerTypeName = L"DomainManager"; LPCWSTR szMainMethodName = L"Main"; int nprops = sizeof(property_keys) / sizeof(wchar_t*); hr = pCLRRuntimeHost->CreateAppDomainWithManager( L"klr.core45.managed", dwFlagsAppDomain, szAssemblyName, szDomainManagerTypeName, nprops, property_keys, property_values, &domainId); if (FAILED(hr)) { printf_s("Failed to create app domain (%d).\n", hr); return false; } HostMain pHostMain; hr = pCLRRuntimeHost->CreateDelegate( domainId, szAssemblyName, szDomainManagerTypeName, szMainMethodName, (INT_PTR*)&pHostMain); if (FAILED(hr)) { printf_s("Failed to create main delegate (%d).\n", hr); return false; } // Call main data->exitcode = pHostMain(szCurrentDirectory, data->argc, data->argv); pCLRRuntimeHost->UnloadAppDomain(domainId, true); pCLRRuntimeHost->Stop(); return hr; }