FCIMPLEND
FCIMPL1(Object*, AssemblyNameNative::ToString, Object* refThisUNSAFE)
{
FCALL_CONTRACT;
OBJECTREF pObj = NULL;
ASSEMBLYNAMEREF pThis = (ASSEMBLYNAMEREF) (OBJECTREF) refThisUNSAFE;
HELPER_METHOD_FRAME_BEGIN_RET_1(pThis);
if (pThis == NULL)
COMPlusThrow(kNullReferenceException, W("NullReference_This"));
Thread *pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
AssemblySpec spec;
spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &pThis, FALSE, FALSE);
StackSString name;
#ifndef FEATURE_FUSION
spec.GetFileOrDisplayName(ASM_DISPLAYF_VERSION |
ASM_DISPLAYF_CULTURE |
ASM_DISPLAYF_PUBLIC_KEY_TOKEN,
name);
#else
spec.GetFileOrDisplayName(0, name);
#endif // FEATURE_FUSION
pObj = (OBJECTREF) StringObject::NewString(name);
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(pObj);
}
HRESULT AssemblySpec::LoadAssembly(LPCWSTR pFilePath,
Assembly **ppAssembly, OBJECTREF *pThrowable)
{
AssemblySpec spec;
spec.SetCodeBase(pFilePath, (DWORD) wcslen(pFilePath)+1);
return spec.LoadAssembly(ppAssembly, pThrowable);
}
HRESULT AssemblySpec::InitializeSpec(mdToken kAssemblyRef, IMDInternalImport *pImport, Assembly* pAssembly)
{
HRESULT hr = S_OK;
m_fParsed = TRUE;
DWORD rid = RidFromToken(kAssemblyRef);
if((rid == 0)||(rid > pImport->GetCountWithTokenKind(mdtAssemblyRef))) {
BAD_FORMAT_ASSERT(!"AssemblyRef Token Out of Range");
return COR_E_BADIMAGEFORMAT;
}
// Hash algorithm used to find this hash is saved in Assembly def
pImport->GetAssemblyRefProps(kAssemblyRef, // [IN] The AssemblyRef for which to get the properties.
(const void**) &m_pbPublicKeyOrToken, // [OUT] Pointer to the public key or token.
&m_cbPublicKeyOrToken, // [OUT] Count of bytes in the public key or token.
&m_pAssemblyName, // [OUT] Buffer to fill with name.
&m_context, // [OUT] Assembly MetaData.
NULL, // [OUT] Hash blob.
NULL, // [OUT] Count of bytes in the hash blob.
&m_dwFlags); // [OUT] Flags.
if ((!m_pAssemblyName) ||
(*m_pAssemblyName == 0)) {
BAD_FORMAT_ASSERT(!"NULL AssemblyRef Name");
return COR_E_BADIMAGEFORMAT;
}
MAKE_WIDEPTR_FROMUTF8(pwName,m_pAssemblyName);
if (wcschr(pwName,'\\')
|| wcschr(pwName,'/')
|| wcschr(pwName,':')
|| (RunningOnWin95() && ContainsUnmappableANSIChars(pwName))) {
BAD_FORMAT_ASSERT(!"Bad AssemblyRef Name");
return COR_E_BADIMAGEFORMAT;
}
if((!m_pbPublicKeyOrToken) && (m_cbPublicKeyOrToken != 0)) {
BAD_FORMAT_ASSERT(!"NULL Public Key or Token of AssemblyRef");
return COR_E_BADIMAGEFORMAT;
}
// Let's get the CodeBase from the caller and use it as a hint
if(pAssembly && (!pAssembly->IsShared()))
m_CodeInfo.SetParentAssembly(pAssembly->GetFusionAssembly());
#if defined(_DEBUG) && defined(FUSION_SUPPORTED)
{
// Test fusion conversion
IAssemblyName *pFusionName;
_ASSERTE(CreateFusionName(&pFusionName, TRUE) == S_OK);
AssemblySpec testFusion;
_ASSERTE(testFusion.InitializeSpec(pFusionName) == S_OK);
pFusionName->Release();
}
#endif // _DEBUG && FUSION_SUPPORTED
return hr;
}
FCIMPL1(Object*, AssemblyNameNative::GetFileInformation, StringObject* filenameUNSAFE)
{
FCALL_CONTRACT;
struct _gc
{
ASSEMBLYNAMEREF result;
STRINGREF filename;
} gc;
gc.result = NULL;
gc.filename = (STRINGREF) filenameUNSAFE;
HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
if (gc.filename == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_FileName"));
if (gc.filename->GetStringLength() == 0)
COMPlusThrow(kArgumentException, W("Argument_EmptyFileName"));
gc.result = (ASSEMBLYNAMEREF) AllocateObject(MscorlibBinder::GetClass(CLASS__ASSEMBLY_NAME));
///////////////////////////////////////////////
SString sFileName(gc.filename->GetBuffer());
PEImageHolder pImage = PEImage::OpenImage(sFileName, MDInternalImport_NoCache);
EX_TRY
{
#ifdef FEATURE_CORECLR
// Allow AssemblyLoadContext.GetAssemblyName for native images on CoreCLR
if (pImage->HasNTHeaders() && pImage->HasCorHeader() && pImage->HasNativeHeader())
pImage->VerifyIsNIAssembly();
else
pImage->VerifyIsAssembly();
#else
pImage->VerifyIsAssembly();
#endif
}
EX_CATCH
{
Exception *ex = GET_EXCEPTION();
EEFileLoadException::Throw(sFileName,ex->GetHR(),ex);
}
EX_END_CATCH_UNREACHABLE;
SString sUrl = sFileName;
PEAssembly::PathToUrl(sUrl);
AssemblySpec spec;
spec.InitializeSpec(TokenFromRid(mdtAssembly,1),pImage->GetMDImport(),NULL,TRUE);
spec.SetCodeBase(sUrl);
spec.AssemblyNameInit(&gc.result, pImage);
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(gc.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;
};
FCIMPLEND
#endif // !FEATURE_CORECLR
FCIMPL4(void, AssemblyNameNative::Init, Object * refThisUNSAFE, OBJECTREF * pAssemblyRef, CLR_BOOL fForIntrospection, CLR_BOOL fRaiseResolveEvent)
{
FCALL_CONTRACT;
ASSEMBLYNAMEREF pThis = (ASSEMBLYNAMEREF) (OBJECTREF) refThisUNSAFE;
HRESULT hr = S_OK;
HELPER_METHOD_FRAME_BEGIN_1(pThis);
*pAssemblyRef = NULL;
if (pThis == NULL)
COMPlusThrow(kNullReferenceException, W("NullReference_This"));
Thread * pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
AssemblySpec spec;
hr = spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF *) &pThis, TRUE, FALSE);
if (SUCCEEDED(hr))
{
spec.AssemblyNameInit(&pThis,NULL);
}
else if ((hr == FUSION_E_INVALID_NAME) && fRaiseResolveEvent)
{
Assembly * pAssembly = GetAppDomain()->RaiseAssemblyResolveEvent(&spec, fForIntrospection, FALSE);
if (pAssembly == NULL)
{
EEFileLoadException::Throw(&spec, hr);
}
else
{
*((OBJECTREF *) (&(*pAssemblyRef))) = pAssembly->GetExposedObject();
}
}
else
{
ThrowHR(hr);
}
HELPER_METHOD_FRAME_END();
}
HRESULT AssemblySpec::LoadAssembly(LPCSTR pSimpleName,
AssemblyMetaDataInternal* pContext,
PBYTE pbPublicKeyOrToken,
DWORD cbPublicKeyOrToken,
DWORD dwFlags,
Assembly** ppAssembly,
OBJECTREF* pThrowable)
{
HRESULT hr = S_OK;
AssemblySpec spec;
hr = spec.Init(pSimpleName, pContext,
pbPublicKeyOrToken, cbPublicKeyOrToken, dwFlags);
if (SUCCEEDED(hr))
hr = spec.LoadAssembly(ppAssembly, pThrowable);
return hr;
}
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);
}
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;
}