summaryrefslogtreecommitdiff
path: root/src/inc/legacyactivationshimutil.h
diff options
context:
space:
mode:
authorJiyoung Yun <jy910.yun@samsung.com>2016-11-23 10:09:09 (GMT)
committerJiyoung Yun <jy910.yun@samsung.com>2016-11-23 10:09:09 (GMT)
commit4b4aad7217d3292650e77eec2cf4c198ea9c3b4b (patch)
tree98110734c91668dfdbb126fcc0e15ddbd93738ca /src/inc/legacyactivationshimutil.h
parentfa45f57ed55137c75ac870356a1b8f76c84b229c (diff)
downloadcoreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.zip
coreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.tar.gz
coreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.tar.bz2
Imported Upstream version 1.1.0upstream/1.1.0
Diffstat (limited to 'src/inc/legacyactivationshimutil.h')
-rw-r--r--src/inc/legacyactivationshimutil.h1116
1 files changed, 1116 insertions, 0 deletions
diff --git a/src/inc/legacyactivationshimutil.h b/src/inc/legacyactivationshimutil.h
new file mode 100644
index 0000000..4e6cdf0
--- /dev/null
+++ b/src/inc/legacyactivationshimutil.h
@@ -0,0 +1,1116 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+//
+// LegacyActivationShim.h
+//
+// This file allows simple migration from .NET Runtime v2 Host Activation APIs
+// to the .NET Runtime v4 Host Activation APIs through simple shim functions.
+
+#ifndef __LEGACYACTIVATIONSHIMUTIL_H__
+#define __LEGACYACTIVATIONSHIMUTIL_H__
+
+// To minimize how much we perturb sources that we are included in, we make sure that
+// all macros we define/redefine are restored at the end of the header.
+#pragma push_macro("SELECTANY")
+#pragma push_macro("_TEXT_ENCODE")
+#pragma push_macro("countof")
+#pragma push_macro("UNUSED")
+
+#ifndef _MSC_VER
+#error "LegacyActivationShim.h cannot be used on non-MS compilers"
+#endif
+
+// ---SELECTANY------------------------------------------------------------------------------------
+#undef SELECTANY
+#define SELECTANY extern __declspec(selectany)
+
+// Allow users of these headers to provide custom 'LoadLibrary' implementation (e.g. WszLoadLibrary).
+// Example of usage is in ndp\clr\src\fusion\tools\viewer.
+#ifndef LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY
+#define LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY ::LoadLibrary
+#endif
+
+// _T macro alternative to make strings ASCII/UNICODE
+#undef _TEXT_ENCODE
+#ifdef UNICODE
+#define _TEXT_ENCODE(str) L ## str
+#else //!UNICODE
+#define _TEXT_ENCODE(str) str
+#endif //!UNICODE
+
+// countof ... number of items in an array
+#ifndef countof
+#define countof(x) (sizeof(x) / sizeof(x[0]))
+#endif countof
+
+#ifndef UNUSED
+#define UNUSED(var) ((void)(var))
+#endif //UNUSED
+
+#ifndef __LEGACYACTIVATIONSHIM_H__
+ #error Error: Include LegacyActivationShim.h or LegacyActivationShimDelayLoad.h instead of directly including LegacyActivationShimUtil.h
+#endif // __LEGACYACTIVATIONSHIM_H__
+
+// ---PLACEMENT NEW--------------------------------------------------------------------------------
+#ifndef __PLACEMENT_NEW_INLINE
+#define __PLACEMENT_NEW_INLINE
+// Inline placement new
+inline void* operator new(size_t, void *_Where)
+{ // construct array with placement at _Where
+ return (_Where);
+}
+
+// delete if placement new fails
+inline void operator delete(void *, void *)
+{
+}
+#endif __PLACEMENT_NEW_INLINE
+
+// ---LEGACYACTIVATON NAMESPACE--------------------------------------------------------------------
+namespace LegacyActivationShim
+{
+ // ---UTIL NAMESPACE---------------------------------------------------------------------------
+ namespace Util
+ {
+ // ---INTERLOCKEDCOMPAREEXCHANGEPOINTERT---------------------------------------------------
+ // Variation on InterlockedCompareExchangePointer that adds some type safety.
+ // Added 'T' to end of name because an identical name to the original function
+ // confuses GCC
+ template <typename T>
+ inline
+ T InterlockedCompareExchangePointerT(
+ T volatile* destination,
+ T exchange,
+ T comparand)
+ {
+#ifdef __UtilCode_h__
+ // Utilcode has redefined InterlockedCompareExchangePointer
+ return ::InterlockedCompareExchangeT(destination, exchange, comparand);
+#else // __UtilCode_h__
+ return reinterpret_cast<T>(InterlockedCompareExchangePointer(
+ (PVOID volatile *)(destination),
+ (PVOID)(exchange),
+ (PVOID)(comparand)));
+#endif // __UtilCode_h__ else
+ }
+
+ // ---PlacementNewDeleteHelper-------------------------------------------------------------
+ template <typename TYPE, bool IS_CLASS>
+ class PlacementNewDeleteHelper;
+
+ template <typename TYPE>
+ class PlacementNewDeleteHelper<TYPE, true>
+ {
+ public:
+ // Some environments #define New and Delete, so name these functions
+ // Construct and Destruct to keep them unique.
+ static void Construct(TYPE const & value, void *pvWhere)
+ { new (pvWhere) TYPE(value); }
+
+ static void Destruct(TYPE & value)
+ { value.~TYPE(); }
+ };
+
+ template <typename TYPE>
+ class PlacementNewDeleteHelper<TYPE, false>
+ {
+ public:
+ static void Construct(TYPE const & value, void *pvWhere)
+ { *reinterpret_cast<TYPE *>(pvWhere) = value; }
+
+ static void Destruct(TYPE &)
+ { }
+ };
+
+ // ---HOLDERBASE---------------------------------------------------------------------------
+ template <typename TYPE>
+ class HolderBase
+ {
+ public:
+ // Relies on implicit default constructor, which permits zero-init static
+ // object declaration. Do not define one.
+ // HolderBase() {}
+
+ protected:
+ char m_value[sizeof(TYPE)];
+
+ inline
+ TYPE & GetRef()
+ { return *reinterpret_cast<TYPE *>(&m_value[0]); }
+
+ inline
+ TYPE & GetPtr()
+ { return reinterpret_cast<TYPE *>(&m_value[0]); }
+
+ inline
+ void Construct(TYPE const & value)
+ { PlacementNewDeleteHelper<TYPE, __is_class(TYPE)>::Construct(value, (void *)&m_value[0]); }
+
+ inline
+ void Destruct()
+ { PlacementNewDeleteHelper<TYPE, __is_class(TYPE)>::Destruct(GetRef()); }
+ };
+
+ // ---HOLDER-------------------------------------------------------------------------------
+ template <typename TYPE, void (*ASSIGNF)(TYPE &), void (*RELEASEF)(TYPE &)>
+ class Holder : public HolderBase<TYPE>
+ {
+ protected:
+ bool m_assigned;
+ bool m_suppressed;
+
+ public:
+ inline
+ Holder() : m_assigned(false), m_suppressed(false)
+ {}
+
+ inline
+ Holder(TYPE const & value) : m_assigned(false), m_suppressed(false)
+ { Assign(value); }
+
+ inline
+ ~Holder()
+ { Release(); }
+
+ inline
+ void Assign(TYPE const & value)
+ {
+ Release();
+ Construct(value);
+ m_assigned = true;
+ (*ASSIGNF)(GetValue());
+ }
+
+ inline
+ void Release()
+ {
+ if (m_assigned)
+ {
+ if (!m_suppressed)
+ {
+ (*RELEASEF)(GetValue());
+ }
+ m_assigned = false;
+ m_suppressed = false;
+ Destruct();
+ }
+ }
+
+ inline
+ void SuppressRelease()
+ {
+ m_suppressed = m_assigned;
+ }
+
+ inline
+ TYPE & GetValue()
+ {
+ // _ASSERTE(m_assigned);
+ return GetRef();
+ }
+
+ inline
+ bool IsAssigned()
+ { return m_assigned; }
+ };
+
+ // ---ZEROINITGLOBALHOLDER-----------------------------------------------------------------
+ // This class should ONLY be used for global (file scope) variables. It relies on zero
+ // initialized data in the image. This will fail miserably for other scenarios, as the
+ // memory used for the object may not be zero-initialized, which will result in incorrect
+ // behaviour.
+ template <typename TYPE, void (*ASSIGNF)(TYPE &), void (*RELEASEF)(TYPE &)>
+ class ZeroInitGlobalHolder : public HolderBase<TYPE>
+ {
+ protected:
+ bool m_assigned;
+
+ public:
+ // Relies on implicit default constructor, which permits zero-init static
+ // field declaration. Do not define an explicit constructor.
+ // ZeroInitGlobalHolder() {}
+
+ inline
+ ~ZeroInitGlobalHolder()
+ { Release(); }
+
+ inline
+ void Assign(TYPE const & value)
+ {
+ Release();
+ Construct(value);
+ m_assigned = true;
+ (*ASSIGNF)(GetValue());
+ }
+
+ inline
+ void Release()
+ {
+ if (m_assigned)
+ {
+ (*RELEASEF)(GetValue());
+ m_assigned = false;
+ Destruct();
+ }
+ }
+
+ inline
+ TYPE & GetValue()
+ {
+ // _ASSERTE(m_assigned);
+ return GetRef();
+ }
+
+ inline
+ bool IsAssigned()
+ { return m_assigned; }
+
+ inline
+ void ClearUnsafe()
+ { m_assigned = false; }
+ };
+
+ // ---DONOTHINGHELPER----------------------------------------------------------------------
+ template <typename TYPE>
+ inline
+ void DoNothingHelper(TYPE & value)
+ { UNUSED(value); }
+
+ // ---RELEASEHELPER------------------------------------------------------------------------
+ template <typename TYPE>
+ inline
+ void ReleaseHelper(TYPE & value)
+ { value->Release(); }
+
+ // ---RELEASEHOLDER------------------------------------------------------------------------
+ template <typename TYPE>
+ class ReleaseHolder
+ : public Holder< TYPE, &DoNothingHelper<TYPE>, &ReleaseHelper<TYPE> >
+ {
+ public:
+ inline
+ ReleaseHolder(TYPE & value)
+ : Holder< TYPE, &DoNothingHelper<TYPE>, &ReleaseHelper<TYPE> >(value)
+ {}
+
+ ReleaseHolder()
+ : Holder< TYPE, &DoNothingHelper<TYPE>, &ReleaseHelper<TYPE> >()
+ {}
+ };
+
+ // ---ZEROINITGLOBALRELEASEHOLDER----------------------------------------------------------
+ template <typename TYPE>
+ class ZeroInitGlobalReleaseHolder
+ : public ZeroInitGlobalHolder< TYPE, &DoNothingHelper<TYPE>, &ReleaseHelper<TYPE> >
+ {
+ };
+
+ // ---FREELIBRARYHELPER--------------------------------------------------------------------
+ inline
+ void FreeLibraryHelper(HMODULE & hMod)
+ {
+ FreeLibrary(hMod);
+ }
+
+ // ---HMODULEHOLDER------------------------------------------------------------------------
+ class HMODULEHolder
+ : public Holder< HMODULE, &DoNothingHelper<HMODULE>, &FreeLibraryHelper >
+ {
+ public:
+ inline
+ HMODULEHolder(HMODULE value)
+ : Holder< HMODULE, &DoNothingHelper<HMODULE>, &FreeLibraryHelper >(value)
+ {}
+
+ HMODULEHolder()
+ : Holder< HMODULE, &DoNothingHelper<HMODULE>, &FreeLibraryHelper >()
+ {}
+ };
+
+ // ---ZEROINITHMODULEHOLDER----------------------------------------------------------------
+ class ZeroInitGlobalHMODULEHolder
+ : public ZeroInitGlobalHolder< HMODULE, &DoNothingHelper<HMODULE>, &FreeLibraryHelper >
+ {
+ };
+
+ // ---DELAYLOADFUNCTOR---------------------------------------------------------------------
+ // T must be a function typedef.
+ // For example, "typedef int X(short i); DelayLoadFunctor<X> pfnX;"
+ template <typename T>
+ class DelayLoadFunctor
+ {
+ private:
+ HMODULEHolder m_hModHolder;
+ T * m_proc;
+
+ public:
+ HRESULT Init(LPCTSTR wzDllName, LPCSTR szProcName)
+ {
+ // Load module
+ HMODULE hMod = LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY(wzDllName);
+ if (hMod == NULL)
+ return HRESULT_FROM_WIN32(::GetLastError());
+ HMODULEHolder hModHolder(hMod);
+
+ // Load proc address
+ T * proc = reinterpret_cast<T *>(::GetProcAddress(hMod, szProcName));
+ if (proc == NULL)
+ return HRESULT_FROM_WIN32(::GetLastError());
+
+ // Store results
+ hModHolder.SuppressRelease();
+ m_hModHolder.Assign(hMod);
+ m_proc = proc;
+
+ return S_OK;
+ }
+
+ HRESULT Init(HMODULE hMod, LPCSTR szProcName)
+ {
+ // Load proc address
+ T * proc = reinterpret_cast<T *>(::GetProcAddress(hMod, szProcName));
+ if (proc == NULL)
+ return HRESULT_FROM_WIN32(::GetLastError());
+
+ // Store result
+ m_proc = proc;
+
+ // Success
+ return S_OK;
+ }
+
+ T& operator()()
+ {
+ return *m_proc;
+ }
+ };
+
+ // ---ZEROINITGLOBALSPINLOCK----------------------------------------------------------------
+ class ZeroInitGlobalSpinLock
+ {
+ private:
+ enum LOCK_STATE
+ {
+ UNLOCKED = 0,
+ LOCKED = 1
+ };
+
+ LONG volatile m_lock;
+
+ static inline void Lock(ZeroInitGlobalSpinLock*& lock)
+ {
+ while (InterlockedExchange(&lock->m_lock, LOCKED) == LOCKED)
+ {
+ ::SwitchToThread();
+ }
+ }
+
+ static inline void Unlock(ZeroInitGlobalSpinLock*& lock)
+ { InterlockedExchange(&lock->m_lock, UNLOCKED); }
+
+ public:
+ typedef LegacyActivationShim::Util::Holder<ZeroInitGlobalSpinLock*,
+ &ZeroInitGlobalSpinLock::Lock,
+ &ZeroInitGlobalSpinLock::Unlock>
+ Holder;
+ };
+
+ // ---MSCOREEDATA--------------------------------------------------------------------------
+ SELECTANY HMODULE g_hModMscoree = NULL;
+ SELECTANY ZeroInitGlobalHMODULEHolder g_hModMscoreeHolder;
+
+ // ---GETMSCOREE---------------------------------------------------------------------------
+ inline
+ HRESULT GetMSCOREE(HMODULE *pMscoree)
+ {
+ if (g_hModMscoree == NULL)
+ {
+ HMODULE hModMscoree = LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY(_TEXT_ENCODE("mscoree.dll"));
+ if (hModMscoree == NULL)
+ return HRESULT_FROM_WIN32(GetLastError());
+ HMODULEHolder hModMscoreeHolder(hModMscoree);
+
+ if (LegacyActivationShim::Util::InterlockedCompareExchangePointerT<HMODULE>(
+ &g_hModMscoree, hModMscoree, NULL) == NULL)
+ {
+ g_hModMscoreeHolder.ClearUnsafe();
+ g_hModMscoreeHolder.Assign(g_hModMscoree);
+ hModMscoreeHolder.SuppressRelease();
+ }
+ }
+
+ *pMscoree = g_hModMscoree;
+ return S_OK;
+ }
+
+ // ---MSCOREEFUNCTOR-----------------------------------------------------------------------
+ template <typename T>
+ class MscoreeFunctor : public DelayLoadFunctor<T>
+ {
+ public:
+ HRESULT Init(LPCSTR szProcName)
+ {
+ HRESULT hr = S_OK;
+ HMODULE hModMscoree = NULL;
+ IfHrFailRet(GetMSCOREE(&hModMscoree));
+
+ return DelayLoadFunctor<T>::Init(hModMscoree, szProcName);
+ }
+ };
+
+ // ---CALLCLRCREATEINSTANCE------------------------------------------------------------------
+ inline
+ HRESULT CallCLRCreateInstance(
+ REFCLSID clsid,
+ REFIID riid,
+ LPVOID *ppInterface)
+ {
+ HRESULT hr = S_OK;
+ HMODULE hMscoree = NULL;
+ IfHrFailRet(GetMSCOREE(&hMscoree));
+
+ typedef HRESULT (__stdcall *CLRCreateInstance_pfn) (
+ REFCLSID clsid,
+ REFIID riid,
+ LPVOID *ppInterface);
+
+ CLRCreateInstance_pfn pfnCLRCreateInstance =
+ reinterpret_cast<CLRCreateInstance_pfn>(GetProcAddress(hMscoree, "CLRCreateInstance"));
+
+ if (pfnCLRCreateInstance == NULL)
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ return (*pfnCLRCreateInstance)(
+ clsid,
+ riid,
+ ppInterface);
+ }
+
+ // ---CLRMETAHOST INTERFACE DATA-----------------------------------------------------------
+ SELECTANY ICLRMetaHost* g_pCLRMetaHost = NULL;
+ SELECTANY ZeroInitGlobalReleaseHolder<ICLRMetaHost*> g_hCLRMetaHost;
+
+ // ---GETCLRMETAHOST-----------------------------------------------------------------------
+ // NOTE: Does not AddRef returned interface pointer.
+ inline
+ HRESULT GetCLRMetaHost(
+ /*out*/ ICLRMetaHost **ppCLRMetaHost)
+ {
+ HRESULT hr = S_OK;
+
+ if (g_pCLRMetaHost == NULL)
+ {
+ ICLRMetaHost *pMetaHost = NULL;
+ IfHrFailRet(CallCLRCreateInstance(CLSID_CLRMetaHost,
+ IID_ICLRMetaHost,
+ reinterpret_cast<LPVOID *>(&pMetaHost)));
+ ReleaseHolder<ICLRMetaHost*> hMetaHost(pMetaHost);
+
+ //
+ // Great - we got an ICLRMetaHost. Now publish this to
+ // g_pCLRMetaHost in a thread-safe way.
+ //
+
+ if (LegacyActivationShim::Util::InterlockedCompareExchangePointerT<ICLRMetaHost *>(
+ &g_pCLRMetaHost, pMetaHost, NULL) == NULL)
+ {
+ // Successful publish. In this case, we also assign to the
+ // holder to ensure that the interface is released when the
+ // image is unloaded.
+ g_hCLRMetaHost.ClearUnsafe();
+ g_hCLRMetaHost.Assign(g_pCLRMetaHost);
+ hMetaHost.SuppressRelease(); // Keep it AddRef'ed for the g_hCLRMetaHost
+ }
+ }
+
+ *ppCLRMetaHost = g_pCLRMetaHost;
+
+ return hr;
+ }
+
+ // ---HasNewActivationAPIs-----------------------------------------------------------------
+ SELECTANY ULONG g_fHasNewActivationAPIs = ULONG(-1);
+
+ inline
+ bool HasNewActivationAPIs()
+ {
+ if (g_fHasNewActivationAPIs == ULONG(-1))
+ {
+ ICLRMetaHost *pMetaHost = NULL;
+ HRESULT hr = GetCLRMetaHost(&pMetaHost);
+ InterlockedCompareExchange((LONG volatile *)&g_fHasNewActivationAPIs, (LONG)(SUCCEEDED(hr)), ULONG(-1));
+ }
+
+ return g_fHasNewActivationAPIs != 0;
+ }
+
+ // ---CLRMETAHOSTPOLICY INTERFACE DATA-----------------------------------------------------
+ SELECTANY ICLRMetaHostPolicy* g_pCLRMetaHostPolicy = NULL;
+ SELECTANY ZeroInitGlobalReleaseHolder<ICLRMetaHostPolicy*> g_hCLRMetaHostPolicy;
+
+ // ---GETCLRMETAHOSTPOLICY-----------------------------------------------------------------
+ // NOTE: Does not AddRef returned interface pointer.
+ inline
+ HRESULT GetCLRMetaHostPolicy(
+ /*out*/ ICLRMetaHostPolicy **ppICLRMetaHostPolicy)
+ {
+ HRESULT hr = S_OK;
+
+ if (g_pCLRMetaHostPolicy == NULL)
+ {
+ ICLRMetaHostPolicy *pMetaHostPolicy = NULL;
+ IfHrFailRet(CallCLRCreateInstance(CLSID_CLRMetaHostPolicy,
+ IID_ICLRMetaHostPolicy,
+ reinterpret_cast<LPVOID *>(&pMetaHostPolicy)));
+ ReleaseHolder<ICLRMetaHostPolicy*> hMetaHostPolicy(pMetaHostPolicy);
+
+ //
+ // Great - we got an ICLRMetaHostPolicy. Now publish this to
+ // g_pCLRMetaHostPolicy in a thread-safe way.
+ //
+
+ if (LegacyActivationShim::Util::InterlockedCompareExchangePointerT<ICLRMetaHostPolicy*>(
+ &g_pCLRMetaHostPolicy, pMetaHostPolicy, NULL) == NULL)
+ {
+ // Successful publish. In this case, we also assign to the
+ // holder to ensure that the interface is released when the
+ // image is unloaded.
+ g_hCLRMetaHostPolicy.ClearUnsafe();
+ g_hCLRMetaHostPolicy.Assign(g_pCLRMetaHostPolicy);
+ hMetaHostPolicy.SuppressRelease();
+ }
+ }
+
+ *ppICLRMetaHostPolicy = g_pCLRMetaHostPolicy;
+
+ return hr;
+ }
+
+ // ---RUNTIMEINFO DATA---------------------------------------------------------------------
+ struct RuntimeInfo
+ {
+ ICLRRuntimeInfo *m_pRuntimeInfo;
+
+ DWORD m_cchImageVersion;
+ WCHAR m_wszImageVersion[512];
+
+ inline
+ void Init()
+ {
+ m_pRuntimeInfo = NULL;
+ m_cchImageVersion = countof(m_wszImageVersion);
+ m_wszImageVersion[0] = L'\0';
+ }
+
+ inline
+ void Release()
+ {
+ if (m_pRuntimeInfo != NULL)
+ {
+ m_pRuntimeInfo->Release();
+ m_pRuntimeInfo = NULL;
+ }
+ }
+ };
+
+ SELECTANY LONG g_runtimeInfoIsInitialized = FALSE;
+ SELECTANY RuntimeInfo g_runtimeInfo;
+ SELECTANY ZeroInitGlobalSpinLock g_runtimeInfoLock;
+ SELECTANY ZeroInitGlobalReleaseHolder<RuntimeInfo*> g_hRuntimeInfo;
+
+ // ---GETCLRRUNTIMEINFOHELPER--------------------------------------------------------------
+ // Logic:
+ // 1. Try to bind using ICLRMetaHostPolicy::GetRequestedRuntime and incoming arguments.
+ // 2. Try to bind using ICLRMetaHostPolicy::GetRequestedRuntime and "v4.0.0" and
+ // upgrade policy.
+ // 3. Try to bind to latest using GetRequestedRuntimeInfo.
+
+ inline
+ HRESULT GetCLRRuntimeInfoHelper(
+ /*out*/ ICLRRuntimeInfo **ppCLRRuntimeInfo,
+ LPCWSTR pEXE = NULL,
+ IStream *pIStream = NULL,
+ __inout_ecount_opt(*pcchVersion) LPWSTR wszVersion = NULL,
+ DWORD *pcchVersion = NULL,
+ __out_ecount_opt(*pcchImageVersion) LPWSTR wszImageVersion = NULL,
+ DWORD *pcchImageVersion = NULL)
+ {
+ HRESULT hr = S_OK;
+
+ //
+ // 1. Try policy-based binding first, which will incorporate config files and such.
+ //
+
+ ICLRMetaHostPolicy *pMetaHostPolicy = NULL;
+ IfHrFailRet(GetCLRMetaHostPolicy(&pMetaHostPolicy));
+
+ DWORD dwConfigFlags = 0;
+
+ hr = pMetaHostPolicy->GetRequestedRuntime(
+ METAHOST_POLICY_USE_PROCESS_IMAGE_PATH,
+ pEXE,
+ pIStream,
+ wszVersion,
+ pcchVersion,
+ wszImageVersion,
+ pcchImageVersion,
+ &dwConfigFlags,
+ IID_ICLRRuntimeInfo,
+ reinterpret_cast<LPVOID *>(ppCLRRuntimeInfo));
+
+ if (hr != S_OK &&
+ pEXE == NULL &&
+ pIStream == NULL &&
+ wszVersion == NULL)
+ { //
+ // 2. Try to bind using ICLRMetaHostPolicy::GetRequestedRuntime and "v4.0.0" and upgrade policy.
+ //
+
+ WCHAR _wszVersion[256]; // We can't use new in this header, so just pick an obscenely long version string length of 256
+ DWORD _cchVersion = countof(_wszVersion);
+ wcscpy_s(_wszVersion, _cchVersion, L"v4.0.0");
+ hr = pMetaHostPolicy->GetRequestedRuntime(
+ static_cast<METAHOST_POLICY_FLAGS>(METAHOST_POLICY_USE_PROCESS_IMAGE_PATH |
+ METAHOST_POLICY_APPLY_UPGRADE_POLICY),
+ pEXE,
+ pIStream, // (is NULL)
+ _wszVersion,
+ &_cchVersion,
+ wszImageVersion,
+ pcchImageVersion,
+ &dwConfigFlags,
+ IID_ICLRRuntimeInfo,
+ reinterpret_cast<LPVOID *>(ppCLRRuntimeInfo));
+ }
+
+ if (hr != S_OK &&
+ pEXE == NULL &&
+ pIStream == NULL &&
+ wszVersion == NULL)
+ { //
+ // 3. Try to bind using GetRequestedRuntimeInfo(NULL)
+ //
+
+ typedef HRESULT __stdcall GetRequestedRuntimeInfo_t(
+ LPCWSTR pExe,
+ LPCWSTR pwszVersion,
+ LPCWSTR pConfigurationFile,
+ DWORD startupFlags,
+ DWORD runtimeInfoFlags,
+ LPWSTR pDirectory,
+ DWORD dwDirectory,
+ DWORD *dwDirectoryLength,
+ LPWSTR pVersion,
+ DWORD cchBuffer,
+ DWORD* dwlength);
+
+ HMODULE hMscoree = NULL;
+ IfHrFailRet(GetMSCOREE(&hMscoree));
+
+ // We're using GetRequestedRuntimeInfo here because it is the only remaining API
+ // that will not be Whidbey-capped and will allow "bind to latest" semantics. This
+ // is cheating a bit, but should work for now. The alternative is to use
+ // ICLRMetaHost::EnumerateRuntimes to achieve the same result.
+ DelayLoadFunctor<GetRequestedRuntimeInfo_t> GetRequestedRuntimeInfoFN;
+ IfHrFailRet(GetRequestedRuntimeInfoFN.Init(hMscoree, "GetRequestedRuntimeInfo"));
+
+ WCHAR szDir_[_MAX_PATH];
+ DWORD cchDir_ = countof(szDir_);
+ WCHAR szVersion_[_MAX_PATH];
+ DWORD cchVersion_ = countof(szVersion_);
+ DWORD dwInfoFlags_ = RUNTIME_INFO_UPGRADE_VERSION
+ | RUNTIME_INFO_DONT_SHOW_ERROR_DIALOG;
+
+ IfHrFailRet(GetRequestedRuntimeInfoFN()(
+ NULL,
+ NULL,
+ NULL,
+ 0,
+ dwInfoFlags_,
+ szDir_,
+ cchDir_,
+ &cchDir_,
+ szVersion_,
+ cchVersion_,
+ &cchVersion_));
+
+ // Unable to get a version to try to load.
+ if (hr != S_OK)
+ {
+ return CLR_E_SHIM_RUNTIMELOAD;
+ }
+
+ ICLRMetaHost *pMetaHost = NULL;
+ IfHrFailRet(GetCLRMetaHost(&pMetaHost));
+
+ hr = pMetaHost->GetRuntime(szVersion_,
+ IID_ICLRRuntimeInfo,
+ reinterpret_cast<LPVOID *>(ppCLRRuntimeInfo));
+
+ if (hr != S_OK)
+ {
+ return CLR_E_SHIM_RUNTIMELOAD;
+ }
+
+ if (wszImageVersion != NULL)
+ {
+ wcsncpy_s(wszImageVersion, *pcchImageVersion, szVersion_, cchVersion_);
+ *pcchImageVersion = cchVersion_;
+ }
+ }
+
+ if (hr == S_OK &&
+ (dwConfigFlags & METAHOST_CONFIG_FLAGS_LEGACY_V2_ACTIVATION_POLICY_MASK) ==
+ METAHOST_CONFIG_FLAGS_LEGACY_V2_ACTIVATION_POLICY_TRUE)
+ { // If the config requested that the runtime be bound as the legacy runtime.
+ IfHrFailRet((*ppCLRRuntimeInfo)->BindAsLegacyV2Runtime());
+ }
+
+ return hr;
+ }
+
+ // ---GETRUNTIMEINFO-----------------------------------------------------------------------
+ inline
+ HRESULT GetRuntimeInfo(
+ /*out*/ RuntimeInfo **ppRuntimeInfo,
+ LPCWSTR pEXE = NULL,
+ IStream *pIStream = NULL,
+ __inout_ecount_opt(*pcchVersion) LPWSTR wszVersion = NULL,
+ DWORD *pcchVersion = NULL)
+ {
+ HRESULT hr = S_OK;
+
+ if (!g_runtimeInfoIsInitialized)
+ {
+ ZeroInitGlobalSpinLock::Holder lock(&g_runtimeInfoLock);
+ if (!g_runtimeInfoIsInitialized)
+ {
+ g_runtimeInfo.Init();
+
+ IfHrFailRet(GetCLRRuntimeInfoHelper(
+ &g_runtimeInfo.m_pRuntimeInfo,
+ pEXE,
+ pIStream,
+ wszVersion,
+ pcchVersion,
+ g_runtimeInfo.m_wszImageVersion,
+ &g_runtimeInfo.m_cchImageVersion));
+
+ //
+ // Initialized - now publish.
+ //
+
+ g_hRuntimeInfo.ClearUnsafe();
+ g_hRuntimeInfo.Assign(&g_runtimeInfo);
+ InterlockedExchange(&g_runtimeInfoIsInitialized, TRUE);
+ }
+ }
+
+ //
+ // Return the struct
+ //
+
+ *ppRuntimeInfo = &g_runtimeInfo;
+ return hr;
+ }
+
+ // --------BINDTOV4------------------------------------------------------------------------
+ // Used by hosted DLLs that require the use of v4 for all their
+ // LegacyActivationShim calls. Can (and should) be called from DllMain,
+ // provided the DLL has a static (non-delayload) dependency on mscoree.dll.
+ inline
+ HRESULT BindToV4()
+ {
+ HRESULT hr = E_FAIL;
+
+ if (!g_runtimeInfoIsInitialized)
+ {
+ ZeroInitGlobalSpinLock::Holder lock(&g_runtimeInfoLock);
+ if (!g_runtimeInfoIsInitialized)
+ {
+ ICLRMetaHostPolicy *pMetaHostPolicy = NULL;
+ IfHrFailRet(GetCLRMetaHostPolicy(&pMetaHostPolicy));
+
+ g_runtimeInfo.Init();
+
+ //
+ // Try to bind using ICLRMetaHostPolicy::GetRequestedRuntime and "v4.0.0" and upgrade policy.
+ //
+
+ WCHAR _wszVersion[256]; // We can't use new in this header, so just pick an obscenely long version string length of 256
+ DWORD _cchVersion = countof(_wszVersion);
+ wcscpy_s(_wszVersion, _cchVersion, L"v4.0.0");
+
+ IfHrFailRet(pMetaHostPolicy->GetRequestedRuntime(
+ METAHOST_POLICY_APPLY_UPGRADE_POLICY,
+ NULL, // image path
+ NULL, // config stream
+ _wszVersion,
+ &_cchVersion,
+ g_runtimeInfo.m_wszImageVersion,
+ &g_runtimeInfo.m_cchImageVersion,
+ NULL, // config flags
+ IID_ICLRRuntimeInfo,
+ reinterpret_cast<LPVOID *>(&g_runtimeInfo.m_pRuntimeInfo)));
+
+ //
+ // Initialized - now publish.
+ //
+
+ g_hRuntimeInfo.ClearUnsafe();
+ g_hRuntimeInfo.Assign(&g_runtimeInfo);
+ InterlockedExchange(&g_runtimeInfoIsInitialized, TRUE);
+
+ hr = S_OK;
+ }
+ }
+
+ return hr;
+ }
+
+ // ---GETCLRRUNTIMEINFO--------------------------------------------------------------------
+ inline
+ HRESULT GetCLRRuntimeInfo(
+ /*out*/ ICLRRuntimeInfo **ppCLRRuntimeInfo,
+ LPCWSTR pEXE = NULL,
+ IStream *pIStream = NULL,
+ __inout_ecount_opt(*pcchVersion) LPWSTR wszVersion = NULL,
+ DWORD *pcchVersion = NULL)
+ {
+ HRESULT hr = S_OK;
+
+ RuntimeInfo *pRuntimeInfo = NULL;
+ IfHrFailRet(GetRuntimeInfo(&pRuntimeInfo, pEXE, pIStream, wszVersion, pcchVersion));
+
+ *ppCLRRuntimeInfo = pRuntimeInfo->m_pRuntimeInfo;
+ return hr;
+ }
+
+ // ---GetConfigImageVersion----------------------------------------------------------------
+ inline
+ HRESULT GetConfigImageVersion(
+ __out_ecount(*pcchBuffer) LPWSTR wzBuffer,
+ DWORD *pcchBuffer)
+ {
+ HRESULT hr = S_OK;
+
+ RuntimeInfo *pRuntimeInfo = NULL;
+ IfHrFailRet(GetRuntimeInfo(&pRuntimeInfo));
+
+ DWORD cchBuffer = *pcchBuffer;
+ *pcchBuffer = pRuntimeInfo->m_cchImageVersion;
+
+ if (cchBuffer <= pRuntimeInfo->m_cchImageVersion)
+ {
+ wcsncpy_s(
+ wzBuffer,
+ cchBuffer,
+ pRuntimeInfo->m_wszImageVersion,
+ pRuntimeInfo->m_cchImageVersion);
+ }
+ else
+ {
+ IfHrFailRet(HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER));
+ }
+
+ return hr;
+ }
+
+ // ---ICLRSTRONGNAME INTERFACE DATA--------------------------------------------------------
+ SELECTANY ICLRStrongName* g_pCLRStrongName = NULL;
+ SELECTANY ZeroInitGlobalReleaseHolder<ICLRStrongName*> g_hCLRStrongName;
+
+ // ---GETCLRSTRONGNAME---------------------------------------------------------------------
+ // NOTE: Does not AddRef returned interface pointer.
+ inline
+ HRESULT GetCLRStrongName(
+ /*out*/ ICLRStrongName **ppCLRStrongName)
+ {
+ HRESULT hr = S_OK;
+
+ if (g_pCLRStrongName == NULL)
+ {
+ ICLRRuntimeInfo *pInfo = NULL;
+ IfHrFailRet(GetCLRRuntimeInfo(&pInfo));
+
+ ICLRStrongName *pStrongName;
+
+ IfHrFailRet(pInfo->GetInterface(
+ CLSID_CLRStrongName,
+ IID_ICLRStrongName,
+ reinterpret_cast<LPVOID *>(&pStrongName)));
+
+ //
+ // Great - we got an ICLRStrongName. Now publish this to
+ // g_pCLRStrongName in a thread-safe way.
+ //
+
+ if (LegacyActivationShim::Util::InterlockedCompareExchangePointerT<ICLRStrongName *>(
+ &g_pCLRStrongName, pStrongName, NULL) == NULL)
+ {
+ // Successful publish. In this case, we also assign to the
+ // holder to ensure that the interface is released when the
+ // image is unloaded.
+ g_hCLRStrongName.ClearUnsafe();
+ g_hCLRStrongName.Assign(g_pCLRStrongName);
+ }
+ else
+ {
+ // We were beat to the punch, don't publish this interface
+ // and make sure we use the published value for consistency.
+ pStrongName->Release();
+ }
+ }
+
+ *ppCLRStrongName = g_pCLRStrongName;
+ return hr;
+ }
+
+ // ---ICLRSTRONGNAME2 INTERFACE DATA--------------------------------------------------------
+ SELECTANY ICLRStrongName2* g_pCLRStrongName2 = NULL;
+ SELECTANY ZeroInitGlobalReleaseHolder<ICLRStrongName2*> g_hCLRStrongName2;
+
+ // ---GETCLRSTRONGNAME2---------------------------------------------------------------------
+ // NOTE: Does not AddRef returned interface pointer.
+ inline
+ HRESULT GetCLRStrongName2(
+ /*out*/ ICLRStrongName2 **ppCLRStrongName2)
+ {
+ HRESULT hr = S_OK;
+
+ if (g_pCLRStrongName2 == NULL)
+ {
+ ICLRRuntimeInfo *pInfo = NULL;
+ IfHrFailRet(GetCLRRuntimeInfo(&pInfo));
+
+ ICLRStrongName2 *pStrongName;
+
+ IfHrFailRet(pInfo->GetInterface(
+ CLSID_CLRStrongName,
+ IID_ICLRStrongName2,
+ reinterpret_cast<LPVOID *>(&pStrongName)));
+
+ //
+ // Great - we got an ICLRStrongName2. Now publish this to
+ // g_pCLRStrongName2 in a thread-safe way.
+ //
+
+ if (LegacyActivationShim::Util::InterlockedCompareExchangePointerT<ICLRStrongName2 *>(
+ &g_pCLRStrongName2, pStrongName, NULL) == NULL)
+ {
+ // Successful publish. In this case, we also assign to the
+ // holder to ensure that the interface is released when the
+ // image is unloaded.
+ g_hCLRStrongName2.ClearUnsafe();
+ g_hCLRStrongName2.Assign(g_pCLRStrongName2);
+ }
+ else
+ {
+ // We were beat to the punch, don't publish this interface
+ // and make sure we use the published value for consistency.
+ pStrongName->Release();
+ }
+ }
+
+ *ppCLRStrongName2 = g_pCLRStrongName2;
+ return hr;
+ }
+
+ // ---AddStartupFlags------------------------------------------------------------------------------
+ inline
+ HRESULT AddStartupFlags(
+ ICLRRuntimeInfo *pInfo,
+ LPCWSTR wszBuildFlavor,
+ DWORD dwStartupFlags,
+ LPCWSTR wszHostConfigFile)
+ {
+ if (wszBuildFlavor != NULL &&
+ (wszBuildFlavor[0] == L's' || wszBuildFlavor[0] == L'S') &&
+ (wszBuildFlavor[1] == L'v' || wszBuildFlavor[1] == L'V') &&
+ (wszBuildFlavor[2] == L'r' || wszBuildFlavor[2] == L'R') &&
+ wszBuildFlavor[3] == 0)
+ {
+ dwStartupFlags |= STARTUP_SERVER_GC;
+ }
+
+ HRESULT hr = S_OK;
+
+ DWORD dwEffectiveStartupFlags = 0;
+ IfHrFailRet(pInfo->GetDefaultStartupFlags(&dwEffectiveStartupFlags, NULL, NULL));
+
+ // Startup flags at this point are either default (i.e. STARTUP_CONCURRENT_GC)
+ // or have been set based on a config file. We want to clear the concurrent
+ // GC flag because we are supplying non-defaults, and combine them with the
+ // user supplied flags. Note that STARTUP_CONCURRENT_GC is never set as part
+ // of reading a config so we are not losing any information here.
+
+ dwEffectiveStartupFlags &= ~STARTUP_CONCURRENT_GC;
+ dwEffectiveStartupFlags |= dwStartupFlags;
+
+ return pInfo->SetDefaultStartupFlags(dwEffectiveStartupFlags, wszHostConfigFile);
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ SELECTANY HMODULE g_hShlwapi = NULL;
+ SELECTANY ZeroInitGlobalHMODULEHolder g_hShlwapiHolder;
+
+ // ------------------------------------------------------------------------------------------------
+ inline
+ HRESULT CreateIStreamFromFile(
+ LPCWSTR wszFilePath,
+ IStream **ppIStream)
+ {
+ HRESULT hr = S_OK;
+ *ppIStream = NULL;
+
+ if (g_hShlwapi == NULL)
+ {
+ HMODULE hShlwapi = LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY(_TEXT_ENCODE("shlwapi.dll"));
+ if (hShlwapi == NULL)
+ return HRESULT_FROM_WIN32(GetLastError());
+ HMODULEHolder hShlwapiHolder(hShlwapi);
+
+ if (LegacyActivationShim::Util::InterlockedCompareExchangePointerT<HMODULE>(
+ &g_hShlwapi, hShlwapi, NULL) == NULL)
+ {
+ g_hShlwapiHolder.ClearUnsafe();
+ g_hShlwapiHolder.Assign(hShlwapi);
+ hShlwapiHolder.SuppressRelease();
+ }
+ }
+
+ typedef HRESULT (__stdcall * SHCreateStreamOnFile_pfn)(
+ LPCWSTR wszFile,
+ DWORD grfMode,
+ IStream **ppstm);
+
+ SHCreateStreamOnFile_pfn pCreateStreamOnFile =
+ reinterpret_cast<SHCreateStreamOnFile_pfn>(GetProcAddress(g_hShlwapi, "SHCreateStreamOnFileW"));
+
+ if (pCreateStreamOnFile == NULL)
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ //_ASSERTE(pCreateStreamOnFile != NULL);
+
+ // Create IStream
+ IStream* pStream(NULL);
+ IfHrFailRet((*pCreateStreamOnFile)(wszFilePath, 0 /*STGM_READ*/, &pStream));
+ ReleaseHolder<IStream*> hStream(pStream);
+
+ // Success, prevent release and assign IStream to out parameter
+ *ppIStream = pStream;
+ hStream.SuppressRelease();
+
+ return S_OK;
+ }
+ }; // namespace Util
+}; // namespace LegacyActivationShim
+
+#pragma pop_macro("UNUSED")
+#pragma pop_macro("countof")
+#pragma pop_macro("_TEXT_ENCODE")
+#pragma pop_macro("SELECTANY")
+
+#endif // __LEGACYACTIVATIONSHIMUTIL_H__
+