// 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__