FCIMPLEND
/// "parse" tells us to parse the simple name of the assembly as if it was the full name
/// almost never the right thing to do, but needed for compat
/* static */
FCIMPL3(FC_BOOL_RET, AssemblyNameNative::ReferenceMatchesDefinition, AssemblyNameBaseObject* refUNSAFE, AssemblyNameBaseObject* defUNSAFE, CLR_BOOL fParse)
{
FCALL_CONTRACT;
struct _gc
{
ASSEMBLYNAMEREF pRef;
ASSEMBLYNAMEREF pDef;
} gc;
gc.pRef = (ASSEMBLYNAMEREF)ObjectToOBJECTREF (refUNSAFE);
gc.pDef = (ASSEMBLYNAMEREF)ObjectToOBJECTREF (defUNSAFE);
BOOL result = FALSE;
HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
Thread *pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
if (gc.pRef == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_AssemblyName"));
if (gc.pDef == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_AssemblyName"));
AssemblySpec refSpec;
refSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pRef, fParse, FALSE);
AssemblySpec defSpec;
defSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pDef, fParse, FALSE);
#ifdef FEATURE_FUSION
SafeComHolder<IAssemblyName> pRefName (NULL);
IfFailThrow(refSpec.CreateFusionName(&pRefName, FALSE));
SafeComHolder <IAssemblyName> pDefName (NULL);
IfFailThrow(defSpec.CreateFusionName(&pDefName, FALSE));
// Order matters: Ref->IsEqual(Def)
result = (S_OK == pRefName->IsEqual(pDefName, ASM_CMPF_IL_ALL));
#else
result=AssemblySpec::RefMatchesDef(&refSpec,&defSpec);
#endif
HELPER_METHOD_FRAME_END();
FC_RETURN_BOOL(result);
}
//=====================================================================================================================
STDMETHODIMP CLRPrivBinderLoadFile::BindAssemblyExplicit(
PEImage* pImage,
IAssemblyName **ppAssemblyName,
ICLRPrivAssembly ** ppAssembly)
{
STANDARD_BIND_CONTRACT;
PRECONDITION(AppDomain::GetCurrentDomain()->IsDefaultDomain());
VALIDATE_ARG_RET(pImage != nullptr);
VALIDATE_ARG_RET(ppAssemblyName != nullptr);
VALIDATE_ARG_RET(ppAssembly != nullptr);
HRESULT hr = S_OK;
fusion::logging::StatusScope logStatus(0, ID_FUSLOG_BINDING_STATUS_LOAD_FILE, &hr);
ReleaseHolder<IAssemblyName> pAssemblyName;
ReleaseHolder<ICLRPrivAssembly> pAssembly;
EX_TRY
{
// check if a framework assembly
{
AssemblySpec spec;
mdAssembly a;
IfFailThrow(pImage->GetMDImport()->GetAssemblyFromScope(&a));
spec.InitializeSpec(a, pImage->GetMDImport(), NULL, false);
IfFailThrow(spec.CreateFusionName(&pAssemblyName));
}
hr = IfTransientFailThrow(m_pFrameworkBinder->BindFusionAssemblyByName(
pAssemblyName,
CLRPrivBinderFusion::kBindingScope_FrameworkSubset,
&pAssembly));
if (FAILED(hr)) // not a Framework assembly
{
ReleaseHolder<CLRPrivResourcePathImpl> pPathResource =
clr::SafeAddRef(new CLRPrivResourcePathImpl(pImage->GetPath().GetUnicode()));
pAssembly = clr::SafeAddRef(new CLRPrivAssemblyLoadFile(this, m_pFrameworkBinder, pPathResource));
hr = S_OK;
}
}
EX_CATCH_HRESULT(hr);
if (SUCCEEDED(hr))
{
*ppAssemblyName = pAssemblyName.Extract();
*ppAssembly = pAssembly.Extract();
}
return hr;
};
HRESULT AssemblySpec::LoadAssembly(Assembly** ppAssembly,
OBJECTREF* pThrowable, /*= NULL*/
OBJECTREF* pExtraEvidence, /*= NULL*/
BOOL fPolicyLoad) /*= FALSE*/
{
IAssembly* pIAssembly = NULL;
HRESULT hr;
Assembly *pAssembly = GetAppDomain()->FindCachedAssembly(this);
if(pAssembly) {
if ((pExtraEvidence != NULL) && (*pExtraEvidence != NULL))
IfFailGo(SECURITY_E_INCOMPATIBLE_EVIDENCE);
*ppAssembly = pAssembly;
return S_FALSE;
}
PEFile *pFile;
IfFailGo(GetAppDomain()->BindAssemblySpec(this,
&pFile,
&pIAssembly,
&pAssembly,
pExtraEvidence,
pThrowable));
// Loaded by AssemblyResolve event handler
if (hr == S_FALSE) {
//If loaded by the AssemblyResolve event, check that
// the public keys are the same as in the AR.
// However, if the found assembly is a dynamically
// created one, security has decided to allow it.
if (m_cbPublicKeyOrToken &&
pAssembly->m_pManifestFile) {
if (!pAssembly->m_cbPublicKey)
IfFailGo(FUSION_E_PRIVATE_ASM_DISALLOWED);
// Ref has the full key
if (m_dwFlags & afPublicKey) {
if ((m_cbPublicKeyOrToken != pAssembly->m_cbPublicKey) ||
memcmp(m_pbPublicKeyOrToken, pAssembly->m_pbPublicKey, m_cbPublicKeyOrToken))
IfFailGo(FUSION_E_REF_DEF_MISMATCH);
}
// Ref has a token
else if (pAssembly->m_cbRefedPublicKeyToken) {
if ((m_cbPublicKeyOrToken != pAssembly->m_cbRefedPublicKeyToken) ||
memcmp(m_pbPublicKeyOrToken,
pAssembly->m_pbRefedPublicKeyToken,
m_cbPublicKeyOrToken))
IfFailGo(FUSION_E_REF_DEF_MISMATCH);
}
else {
if (!StrongNameTokenFromPublicKey(pAssembly->m_pbPublicKey,
pAssembly->m_cbPublicKey,
&pAssembly->m_pbRefedPublicKeyToken,
&pAssembly->m_cbRefedPublicKeyToken))
IfFailGo(StrongNameErrorInfo());
if ((m_cbPublicKeyOrToken != pAssembly->m_cbRefedPublicKeyToken) ||
memcmp(m_pbPublicKeyOrToken,
pAssembly->m_pbRefedPublicKeyToken,
m_cbPublicKeyOrToken))
IfFailGo(FUSION_E_REF_DEF_MISMATCH);
}
}
*ppAssembly = pAssembly;
return S_OK;
}
// Until we can create multiple Assembly objects for a single HMODULE
// we can only store one IAssembly* per Assembly. It is very important
// to maintain the IAssembly* for an image that is in the load-context.
// An Assembly in the load-from-context can bind to an assembly in the
// load-context but not visa-versa. Therefore, if we every get an IAssembly
// from the load-from-context we must make sure that it will never be
// found using a load. If it did then we could end up with Assembly dependencies
// that are wrong. For example, if I do a LoadFrom() on an assembly in the GAC
// and it requires another Assembly that I have preloaded in the load-from-context
// then that dependency gets burnt into the Jitted code. Later on a Load() is
// done on the assembly in the GAC and we single instance it back to the one
// we have gotten from the load-from-context because the HMODULES are the same.
// Now the dependency is wrong because it would not have the preloaded assembly
// if the order was reversed.
if (pIAssembly) {
IFusionLoadContext *pLoadContext;
hr = pIAssembly->GetFusionLoadContext(&pLoadContext);
_ASSERTE(SUCCEEDED(hr));
if (SUCCEEDED(hr)) {
if (pLoadContext->GetContextType() == LOADCTX_TYPE_LOADFROM) {
mdAssembly mda;
if (FAILED(pFile->GetMDImport()->GetAssemblyFromScope(&mda))) {
hr = COR_E_ASSEMBLYEXPECTED;
goto exit;
}
LPCUTF8 psName;
PBYTE pbPublicKey;
DWORD cbPublicKey;
AssemblyMetaDataInternal context;
DWORD dwFlags;
pFile->GetMDImport()->GetAssemblyProps(mda,
(const void**) &pbPublicKey,
&cbPublicKey,
NULL, // hash alg
&psName,
&context,
&dwFlags);
AssemblySpec spec;
if (FAILED(hr = spec.Init(psName,
&context,
pbPublicKey,
cbPublicKey,
dwFlags)))
goto exit;
IAssemblyName* pFoundAssemblyName;
if (FAILED(hr = spec.CreateFusionName(&pFoundAssemblyName, FALSE)))
goto exit;
AssemblySink* pFoundSink = GetAppDomain()->GetAssemblySink();
if(!pFoundSink) {
pFoundAssemblyName->Release();
hr = E_OUTOFMEMORY;
goto exit;
}
IAssembly *pFoundIAssembly;
BEGIN_ENSURE_PREEMPTIVE_GC();
hr = FusionBind::GetAssemblyFromFusion(GetAppDomain()->GetFusionContext(),
pFoundSink,
pFoundAssemblyName,
&spec.m_CodeInfo,
&pFoundIAssembly);
if(SUCCEEDED(hr)) {
DWORD dwFoundSize = MAX_PATH;
WCHAR wszFoundPath[MAX_PATH];
// Get the path to the module containing the manifest
if (SUCCEEDED(pFoundIAssembly->GetManifestModulePath(wszFoundPath,
&dwFoundSize))) {
// Keep the default context's IAssembly if the paths are the same
if (!_wcsicmp(wszFoundPath, pFile->GetFileName())) {
pIAssembly->Release();
pIAssembly = pFoundIAssembly;
// Make sure the new IAssembly isn't holding its own refcount on
// the file (we've just verified we're holding the same file.)
// Otherwise we will leak the handle when we unload the assembly,
// assuming fusion decides to cache this IAssembly pointer
// somewhere internally.
PEFile::ReleaseFusionMetadataImport(pFoundIAssembly);
}
else
pFoundIAssembly->Release();
}
}
pFoundAssemblyName->Release();
pFoundSink->Release();
END_ENSURE_PREEMPTIVE_GC();
hr = S_OK;
}
exit:
pLoadContext->Release();
}
}
// Create the assembly and delay loading the main module.
Module* pModule;
hr = GetAppDomain()->LoadAssembly(pFile,
pIAssembly,
&pModule,
&pAssembly,
pExtraEvidence,
fPolicyLoad,
pThrowable);
BEGIN_ENSURE_PREEMPTIVE_GC();
if(SUCCEEDED(hr)) {
*ppAssembly = pAssembly;
/*HRESULT hrLoose =*/ GetAppDomain()->AddAssemblyToCache(this, pAssembly);
}
if(pIAssembly)
pIAssembly->Release();
END_ENSURE_PREEMPTIVE_GC();
ErrExit:
if (FAILED(hr) && (pThrowable!=NULL)) {
BEGIN_ENSURE_COOPERATIVE_GC();
if ((pThrowable != RETURN_ON_ERROR) && (*pThrowable == NULL)) {
if (m_pAssemblyName)
PostFileLoadException(m_pAssemblyName, FALSE,NULL, hr, pThrowable);
else {
MAKE_UTF8PTR_FROMWIDE(szName, m_CodeInfo.m_pszCodeBase);
PostFileLoadException(szName, TRUE,NULL, hr, pThrowable);
}
}
END_ENSURE_COOPERATIVE_GC();
}
return hr;
}
