diff options
Diffstat (limited to 'src/mscorlib/src/System/Reflection/Assembly.cs')
-rw-r--r-- | src/mscorlib/src/System/Reflection/Assembly.cs | 3075 |
1 files changed, 3075 insertions, 0 deletions
diff --git a/src/mscorlib/src/System/Reflection/Assembly.cs b/src/mscorlib/src/System/Reflection/Assembly.cs new file mode 100644 index 0000000000..938f877984 --- /dev/null +++ b/src/mscorlib/src/System/Reflection/Assembly.cs @@ -0,0 +1,3075 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +/*============================================================================= +** +** +** +** +** +** +** Purpose: For Assembly-related stuff. +** +** +=============================================================================*/ + +namespace System.Reflection +{ + using System; + using System.Collections; + using System.Collections.Generic; + using CultureInfo = System.Globalization.CultureInfo; + using System.Security; + using System.Security.Policy; + using System.Security.Permissions; + using System.IO; + using StringBuilder = System.Text.StringBuilder; + using System.Configuration.Assemblies; + using StackCrawlMark = System.Threading.StackCrawlMark; + using System.Runtime.InteropServices; +#if FEATURE_SERIALIZATION + using BinaryFormatter = System.Runtime.Serialization.Formatters.Binary.BinaryFormatter; +#endif // FEATURE_SERIALIZATION + using System.Runtime.CompilerServices; + using SecurityZone = System.Security.SecurityZone; + using IEvidenceFactory = System.Security.IEvidenceFactory; + using System.Runtime.Serialization; + using Microsoft.Win32; + using System.Threading; + using __HResults = System.__HResults; + using System.Runtime.Versioning; + using System.Diagnostics.Contracts; + + + [Serializable] + [System.Runtime.InteropServices.ComVisible(true)] + public delegate Module ModuleResolveEventHandler(Object sender, ResolveEventArgs e); + + + [Serializable] + [ClassInterface(ClassInterfaceType.None)] + [ComDefaultInterface(typeof(_Assembly))] + [System.Runtime.InteropServices.ComVisible(true)] +#pragma warning disable 618 + [PermissionSetAttribute(SecurityAction.InheritanceDemand, Unrestricted = true)] +#pragma warning restore 618 + public abstract class Assembly : _Assembly, IEvidenceFactory, ICustomAttributeProvider, ISerializable + { + #region constructors + protected Assembly() {} + #endregion + + #region public static methods + + public static String CreateQualifiedName(String assemblyName, String typeName) + { + return typeName + ", " + assemblyName; + } + + public static Assembly GetAssembly(Type type) + { + if (type == null) + throw new ArgumentNullException("type"); + Contract.EndContractBlock(); + + Module m = type.Module; + if (m == null) + return null; + else + return m.Assembly; + } + +#if !FEATURE_CORECLR + public static bool operator ==(Assembly left, Assembly right) + { + if (ReferenceEquals(left, right)) + return true; + + if ((object)left == null || (object)right == null || + left is RuntimeAssembly || right is RuntimeAssembly) + { + return false; + } + return left.Equals(right); + } + + public static bool operator !=(Assembly left, Assembly right) + { + return !(left == right); + } +#endif // !FEATURE_CORECLR + + public override bool Equals(object o) + { + return base.Equals(o); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + // Locate an assembly by the name of the file containing the manifest. +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly LoadFrom(String assemblyFile) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + +#if FEATURE_WINDOWSPHONE + throw new NotSupportedException(Environment.GetResourceString("NotSupported_WindowsPhone", "Assembly.LoadFrom")); +#else +#if FEATURE_LEGACYNETCF + if(CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) { + System.Reflection.Assembly callingAssembly = System.Reflection.Assembly.GetCallingAssembly(); + if(callingAssembly != null && !callingAssembly.IsProfileAssembly) { + string caller = new System.Diagnostics.StackFrame(1).GetMethod().FullName; + string callee = System.Reflection.MethodBase.GetCurrentMethod().FullName; + throw new MethodAccessException(String.Format( + CultureInfo.CurrentCulture, + Environment.GetResourceString("Arg_MethodAccessException_WithCaller"), + caller, + callee)); + } + } +#endif // FEATURE_LEGACYNETCF + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + return RuntimeAssembly.InternalLoadFrom( + assemblyFile, + null, // securityEvidence + null, // hashValue + AssemblyHashAlgorithm.None, + false,// forIntrospection + false,// suppressSecurityChecks + ref stackMark); +#endif // FEATURE_WINDOWSPHONE + } + + // Locate an assembly for reflection by the name of the file containing the manifest. + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly ReflectionOnlyLoadFrom(String assemblyFile) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + return RuntimeAssembly.InternalLoadFrom( + assemblyFile, + null, //securityEvidence + null, //hashValue + AssemblyHashAlgorithm.None, + true, //forIntrospection + false, //suppressSecurityChecks + ref stackMark); + } + + // Evidence is protected in Assembly.Load() + [System.Security.SecuritySafeCritical] // auto-generated + [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of LoadFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")] + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly LoadFrom(String assemblyFile, + Evidence securityEvidence) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + return RuntimeAssembly.InternalLoadFrom( + assemblyFile, + securityEvidence, + null, // hashValue + AssemblyHashAlgorithm.None, + false,// forIntrospection); + false,// suppressSecurityChecks + ref stackMark); + } + + // Evidence is protected in Assembly.Load() + [System.Security.SecuritySafeCritical] // auto-generated + [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of LoadFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")] + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly LoadFrom(String assemblyFile, + Evidence securityEvidence, + byte[] hashValue, + AssemblyHashAlgorithm hashAlgorithm) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + return RuntimeAssembly.InternalLoadFrom( + assemblyFile, + securityEvidence, + hashValue, + hashAlgorithm, + false, + false, + ref stackMark); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly LoadFrom(String assemblyFile, + byte[] hashValue, + AssemblyHashAlgorithm hashAlgorithm) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + return RuntimeAssembly.InternalLoadFrom( + assemblyFile, + null, + hashValue, + hashAlgorithm, + false, + false, + ref stackMark); + } + +#if FEATURE_CAS_POLICY + // Load an assembly into the LoadFrom context bypassing some security checks + [SecurityCritical] + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly UnsafeLoadFrom(string assemblyFile) + { + + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + return RuntimeAssembly.InternalLoadFrom(assemblyFile, + null, // securityEvidence + null, // hashValue + AssemblyHashAlgorithm.None, + false, // forIntrospection + true, // suppressSecurityChecks + ref stackMark); + } +#endif // FEATURE_CAS_POLICY + + // Locate an assembly by the long form of the assembly name. + // eg. "Toolbox.dll, version=1.1.10.1220, locale=en, publickey=1234567890123456789012345678901234567890" + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly Load(String assemblyString) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, false /*forIntrospection*/); + } + + // Returns type from the assembly while keeping compatibility with Assembly.Load(assemblyString).GetType(typeName) for managed types. + // Calls Type.GetType for WinRT types. + // Note: Type.GetType fails for assembly names that start with weird characters like '['. By calling it for managed types we would + // break AppCompat. + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + internal static Type GetType_Compat(String assemblyString, String typeName) + { + // Normally we would get the stackMark only in public APIs. This is internal API, but it is AppCompat replacement of public API + // call Assembly.Load(assemblyString).GetType(typeName), therefore we take the stackMark here as well, to be fully compatible with + // the call sequence. + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + RuntimeAssembly assembly; + AssemblyName assemblyName = RuntimeAssembly.CreateAssemblyName( + assemblyString, + false /*forIntrospection*/, + out assembly); + + if (assembly == null) { + if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime) { + return Type.GetType(typeName + ", " + assemblyString, true /*throwOnError*/, false /*ignoreCase*/); + } + + assembly = RuntimeAssembly.InternalLoadAssemblyName( + assemblyName, null, null, ref stackMark, + true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/); + } + return assembly.GetType(typeName, true /*throwOnError*/, false /*ignoreCase*/); + } + + // Locate an assembly for reflection by the long form of the assembly name. + // eg. "Toolbox.dll, version=1.1.10.1220, locale=en, publickey=1234567890123456789012345678901234567890" + // + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly ReflectionOnlyLoad(String assemblyString) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, true /*forIntrospection*/); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")] + public static Assembly Load(String assemblyString, Evidence assemblySecurity) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoad(assemblyString, assemblySecurity, ref stackMark, false /*forIntrospection*/); + } + + // Locate an assembly by its name. The name can be strong or + // weak. The assembly is loaded into the domain of the caller. +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly Load(AssemblyName assemblyRef) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + +#if FEATURE_WINDOWSPHONE + if (assemblyRef != null && assemblyRef.CodeBase != null) + { + throw new NotSupportedException(Environment.GetResourceString("NotSupported_AssemblyLoadCodeBase")); + } +#endif + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")] + public static Assembly Load(AssemblyName assemblyRef, Evidence assemblySecurity) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, assemblySecurity, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/); + } + +#if FEATURE_FUSION + [System.Security.SecuritySafeCritical] // auto-generated + [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")] + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly LoadWithPartialName(String partialName) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.LoadWithPartialNameInternal(partialName, null, ref stackMark); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")] + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly LoadWithPartialName(String partialName, Evidence securityEvidence) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.LoadWithPartialNameInternal(partialName, securityEvidence, ref stackMark); + } +#endif // FEATURE_FUSION + + // Loads the assembly with a COFF based IMAGE containing + // an emitted assembly. The assembly is loaded into the domain + // of the caller. +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly Load(byte[] rawAssembly) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + AppDomain.CheckLoadByteArraySupported(); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.nLoadImage( + rawAssembly, + null, // symbol store + null, // evidence + ref stackMark, + false, // fIntrospection + SecurityContextSource.CurrentAssembly); + } + + // Loads the assembly for reflection with a COFF based IMAGE containing + // an emitted assembly. The assembly is loaded into the domain + // of the caller. + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly ReflectionOnlyLoad(byte[] rawAssembly) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + + AppDomain.CheckReflectionOnlyLoadSupported(); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.nLoadImage( + rawAssembly, + null, // symbol store + null, // evidence + ref stackMark, + true, // fIntrospection + SecurityContextSource.CurrentAssembly); + } + + // Loads the assembly with a COFF based IMAGE containing + // an emitted assembly. The assembly is loaded into the domain + // of the caller. The second parameter is the raw bytes + // representing the symbol store that matches the assembly. +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly Load(byte[] rawAssembly, + byte[] rawSymbolStore) + { + + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + AppDomain.CheckLoadByteArraySupported(); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.nLoadImage( + rawAssembly, + rawSymbolStore, + null, // evidence + ref stackMark, + false, // fIntrospection + SecurityContextSource.CurrentAssembly); + } + + // Load an assembly from a byte array, controlling where the grant set of this assembly is + // propigated from. + [SecuritySafeCritical] + [MethodImpl(MethodImplOptions.NoInlining)] // Due to the stack crawl mark + public static Assembly Load(byte[] rawAssembly, + byte[] rawSymbolStore, + SecurityContextSource securityContextSource) + { + + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + AppDomain.CheckLoadByteArraySupported(); + + if (securityContextSource < SecurityContextSource.CurrentAppDomain || + securityContextSource > SecurityContextSource.CurrentAssembly) + { + throw new ArgumentOutOfRangeException("securityContextSource"); + } + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.nLoadImage(rawAssembly, + rawSymbolStore, + null, // evidence + ref stackMark, + false, // fIntrospection + securityContextSource); + } + +#if FEATURE_CAS_POLICY + [System.Security.SecuritySafeCritical] // auto-generated + [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlEvidence)] + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")] + public static Assembly Load(byte[] rawAssembly, + byte[] rawSymbolStore, + Evidence securityEvidence) + { + + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + AppDomain.CheckLoadByteArraySupported(); + + if (securityEvidence != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled) + { + // A zone of MyComputer could not have been used to sandbox, so for compatibility we do not + // throw an exception when we see it. + Zone zone = securityEvidence.GetHostEvidence<Zone>(); + if (zone == null || zone.SecurityZone != SecurityZone.MyComputer) + { + throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit")); + } + } + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.nLoadImage( + rawAssembly, + rawSymbolStore, + securityEvidence, + ref stackMark, + false, // fIntrospection + SecurityContextSource.CurrentAssembly); + } +#endif // FEATURE_CAS_POLICY + + [System.Security.SecuritySafeCritical] // auto-generated + public static Assembly LoadFile(String path) + { + + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + AppDomain.CheckLoadFileSupported(); + + new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path).Demand(); + return RuntimeAssembly.nLoadFile(path, null); + } + +#if FEATURE_CAS_POLICY + [System.Security.SecuritySafeCritical] // auto-generated + [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlEvidence)] + [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of LoadFile which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")] + public static Assembly LoadFile(String path, + Evidence securityEvidence) + { + + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + AppDomain.CheckLoadFileSupported(); + + if (securityEvidence != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled) + throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit")); + + new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path).Demand(); + return RuntimeAssembly.nLoadFile(path, securityEvidence); + } +#endif // FEATURE_CAS_POLICY + +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly Load(Stream assemblyStream, Stream pdbStream) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoadFromStream(assemblyStream, pdbStream, ref stackMark); + } + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly Load(Stream assemblyStream) + { + Contract.Ensures(Contract.Result<Assembly>() != null); + Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly); + + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.InternalLoadFromStream(assemblyStream, null, ref stackMark); + } +#endif //FEATURE_CORECLR + + /* + * Get the assembly that the current code is running from. + */ + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly GetExecutingAssembly() + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeAssembly.GetExecutingAssembly(ref stackMark); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public static Assembly GetCallingAssembly() + { + // LookForMyCallersCaller is not guarantee to return the correct stack frame + // because of inlining, tail calls, etc. As a result GetCallingAssembly is not + // ganranteed to return the correct result. We should document it as such. + StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller; + return RuntimeAssembly.GetExecutingAssembly(ref stackMark); + } + + [System.Security.SecuritySafeCritical] // auto-generated + public static Assembly GetEntryAssembly() { + AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager; + if (domainManager == null) + domainManager = new AppDomainManager(); + return domainManager.EntryAssembly; + } + + #endregion // public static methods + + #region public methods + public virtual event ModuleResolveEventHandler ModuleResolve + { + [System.Security.SecurityCritical] // auto-generated_required + add + { + throw new NotImplementedException(); + } + [System.Security.SecurityCritical] // auto-generated_required + remove + { + throw new NotImplementedException(); + } + } + + public virtual String CodeBase + { +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#endif + get + { + throw new NotImplementedException(); + } + } + + public virtual String EscapedCodeBase + { + [System.Security.SecuritySafeCritical] // auto-generated + get + { + return AssemblyName.EscapeCodeBase(CodeBase); + } + } + +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#endif + public virtual AssemblyName GetName() + { + return GetName(false); + } + +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#endif + public virtual AssemblyName GetName(bool copiedName) + { + throw new NotImplementedException(); + } + + public virtual String FullName + { + get + { + throw new NotImplementedException(); + } + } + + public virtual MethodInfo EntryPoint + { + get + { + throw new NotImplementedException(); + } + } + +#if !FEATURE_CORECLR + Type _Assembly.GetType() + { + return base.GetType(); + } +#endif + + public virtual Type GetType(String name) + { + return GetType(name, false, false); + } + + public virtual Type GetType(String name, bool throwOnError) + { + return GetType(name, throwOnError, false); + } + + public virtual Type GetType(String name, bool throwOnError, bool ignoreCase) + { + throw new NotImplementedException(); + } + + public virtual IEnumerable<Type> ExportedTypes + { + get + { + return GetExportedTypes(); + } + } + + public virtual Type[] GetExportedTypes() + { + throw new NotImplementedException(); + } + + public virtual IEnumerable<TypeInfo> DefinedTypes + { + get + { + Type[] types = GetTypes(); + + TypeInfo[] typeinfos = new TypeInfo[types.Length]; + + for (int i = 0; i < types.Length; i++) + { + + TypeInfo typeinfo = types[i].GetTypeInfo(); + if (typeinfo == null) + throw new NotSupportedException(Environment.GetResourceString("NotSupported_NoTypeInfo", types[i].FullName)); + + typeinfos[i] = typeinfo; + } + + return typeinfos; + } + } + + public virtual Type[] GetTypes() + { + Module[] m = GetModules(false); + + int iNumModules = m.Length; + int iFinalLength = 0; + Type[][] ModuleTypes = new Type[iNumModules][]; + + for (int i = 0; i < iNumModules; i++) + { + ModuleTypes[i] = m[i].GetTypes(); + iFinalLength += ModuleTypes[i].Length; + } + + int iCurrent = 0; + Type[] ret = new Type[iFinalLength]; + for (int i = 0; i < iNumModules; i++) + { + int iLength = ModuleTypes[i].Length; + Array.Copy(ModuleTypes[i], 0, ret, iCurrent, iLength); + iCurrent += iLength; + } + + return ret; + } + + // Load a resource based on the NameSpace of the type. + public virtual Stream GetManifestResourceStream(Type type, String name) + { + throw new NotImplementedException(); + } + + public virtual Stream GetManifestResourceStream(String name) + { + throw new NotImplementedException(); + } + + public virtual Assembly GetSatelliteAssembly(CultureInfo culture) + { + throw new NotImplementedException(); + } + + // Useful for binding to a very specific version of a satellite assembly + public virtual Assembly GetSatelliteAssembly(CultureInfo culture, Version version) + { + throw new NotImplementedException(); + } + +#if FEATURE_CAS_POLICY + public virtual Evidence Evidence + { + get + { + throw new NotImplementedException(); + } + } + + public virtual PermissionSet PermissionSet + { + // SecurityCritical because permissions can contain sensitive information such as paths + [SecurityCritical] + get + { + throw new NotImplementedException(); + } + } + + public bool IsFullyTrusted + { + [SecuritySafeCritical] + get + { + return PermissionSet.IsUnrestricted(); + } + } + + public virtual SecurityRuleSet SecurityRuleSet + { + get + { + throw new NotImplementedException(); + } + } + +#endif // FEATURE_CAS_POLICY + + // ISerializable implementation + [System.Security.SecurityCritical] // auto-generated_required + public virtual void GetObjectData(SerializationInfo info, StreamingContext context) + { + throw new NotImplementedException(); + } + + [ComVisible(false)] + public virtual Module ManifestModule + { + get + { + // This API was made virtual in V4. Code compiled against V2 might use + // "call" rather than "callvirt" to call it. + // This makes sure those code still works. + RuntimeAssembly rtAssembly = this as RuntimeAssembly; + if (rtAssembly != null) + return rtAssembly.ManifestModule; + + throw new NotImplementedException(); + } + } + + public virtual IEnumerable<CustomAttributeData> CustomAttributes + { + get + { + return GetCustomAttributesData(); + } + } + public virtual Object[] GetCustomAttributes(bool inherit) + { + Contract.Ensures(Contract.Result<Object[]>() != null); + throw new NotImplementedException(); + } + + public virtual Object[] GetCustomAttributes(Type attributeType, bool inherit) + { + Contract.Ensures(Contract.Result<Object[]>() != null); + throw new NotImplementedException(); + } + + public virtual bool IsDefined(Type attributeType, bool inherit) + { + throw new NotImplementedException(); + } + +#if FEATURE_LEGACYNETCF + internal virtual bool IsProfileAssembly + { + [System.Security.SecurityCritical] + get + { + throw new NotImplementedException(); + } + } +#endif // FEATURE_LEGACYNETCF + + public virtual IList<CustomAttributeData> GetCustomAttributesData() + { + throw new NotImplementedException(); + } + + // To not break compatibility with the V1 _Assembly interface we need to make this + // new member ComVisible(false). + [ComVisible(false)] + public virtual bool ReflectionOnly + { + get + { + throw new NotImplementedException(); + } + } + +#if FEATURE_MULTIMODULE_ASSEMBLIES + + public Module LoadModule(String moduleName, + byte[] rawModule) + { + return LoadModule(moduleName, rawModule, null); + } + + public virtual Module LoadModule(String moduleName, + byte[] rawModule, + byte[] rawSymbolStore) + { + throw new NotImplementedException(); + } +#endif //FEATURE_MULTIMODULE_ASSEMBLIES + + // + // Locates a type from this assembly and creates an instance of it using + // the system activator. + // + public Object CreateInstance(String typeName) + { + return CreateInstance(typeName, + false, // ignore case + BindingFlags.Public | BindingFlags.Instance, + null, // binder + null, // args + null, // culture + null); // activation attributes + } + + public Object CreateInstance(String typeName, + bool ignoreCase) + { + return CreateInstance(typeName, + ignoreCase, + BindingFlags.Public | BindingFlags.Instance, + null, // binder + null, // args + null, // culture + null); // activation attributes + } + + public virtual Object CreateInstance(String typeName, + bool ignoreCase, + BindingFlags bindingAttr, + Binder binder, + Object[] args, + CultureInfo culture, + Object[] activationAttributes) + { + Type t = GetType(typeName, false, ignoreCase); + if (t == null) return null; + return Activator.CreateInstance(t, + bindingAttr, + binder, + args, + culture, + activationAttributes); + } + + public virtual IEnumerable<Module> Modules + { + get + { + return GetLoadedModules(true); + } + } + + public Module[] GetLoadedModules() + { + return GetLoadedModules(false); + } + + public virtual Module[] GetLoadedModules(bool getResourceModules) + { + throw new NotImplementedException(); + } + + public Module[] GetModules() + { + return GetModules(false); + } + + public virtual Module[] GetModules(bool getResourceModules) + { + throw new NotImplementedException(); + } + + public virtual Module GetModule(String name) + { + throw new NotImplementedException(); + } + + // Returns the file in the File table of the manifest that matches the + // given name. (Name should not include path.) +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#endif + public virtual FileStream GetFile(String name) + { + throw new NotImplementedException(); + } + + public virtual FileStream[] GetFiles() + { + return GetFiles(false); + } + +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#endif + public virtual FileStream[] GetFiles(bool getResourceModules) + { + throw new NotImplementedException(); + } + + // Returns the names of all the resources + public virtual String[] GetManifestResourceNames() + { + throw new NotImplementedException(); + } + + public virtual AssemblyName[] GetReferencedAssemblies() + { + throw new NotImplementedException(); + } + + public virtual ManifestResourceInfo GetManifestResourceInfo(String resourceName) + { + throw new NotImplementedException(); + } + + public override String ToString() + { + String displayName = FullName; + if (displayName == null) + return base.ToString(); + else + return displayName; + } + + public virtual String Location + { +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#endif + get + { + throw new NotImplementedException(); + } + } + + // To not break compatibility with the V1 _Assembly interface we need to make this + // new member ComVisible(false). + [ComVisible(false)] + public virtual String ImageRuntimeVersion + { + get + { + throw new NotImplementedException(); + } + } + + /* + Returns true if the assembly was loaded from the global assembly cache. + */ + public virtual bool GlobalAssemblyCache + { + get + { + throw new NotImplementedException(); + } + } + + [ComVisible(false)] + public virtual Int64 HostContext + { + get + { + // This API was made virtual in V4. Code compiled against V2 might use + // "call" rather than "callvirt" to call it. + // This makes sure those code still works. + RuntimeAssembly rtAssembly = this as RuntimeAssembly; + if (rtAssembly != null) + return rtAssembly.HostContext; + + throw new NotImplementedException(); + } + } + + public virtual bool IsDynamic + { + get + { + return false; + } + } + #endregion // public methods + + } + + // Keep this in sync with LOADCTX_TYPE defined in fusionpriv.idl + internal enum LoadContext + { + DEFAULT, + LOADFROM, + UNKNOWN, + HOSTED, + } + + [Serializable] + internal class RuntimeAssembly : Assembly +#if !FEATURE_CORECLR + , ICustomQueryInterface +#endif + { +#if !FEATURE_CORECLR + #region ICustomQueryInterface + [System.Security.SecurityCritical] + CustomQueryInterfaceResult ICustomQueryInterface.GetInterface([In]ref Guid iid, out IntPtr ppv) + { + if (iid == typeof(NativeMethods.IDispatch).GUID) + { + ppv = Marshal.GetComInterfaceForObject(this, typeof(_Assembly)); + return CustomQueryInterfaceResult.Handled; + } + + ppv = IntPtr.Zero; + return CustomQueryInterfaceResult.NotHandled; + } + #endregion +#endif // !FEATURE_CORECLR + +#if FEATURE_APPX + // The highest byte is the flags and the lowest 3 bytes are + // the cached ctor token of [DynamicallyInvocableAttribute]. + private enum ASSEMBLY_FLAGS : uint + { + ASSEMBLY_FLAGS_UNKNOWN = 0x00000000, + ASSEMBLY_FLAGS_INITIALIZED = 0x01000000, + ASSEMBLY_FLAGS_FRAMEWORK = 0x02000000, + ASSEMBLY_FLAGS_SAFE_REFLECTION = 0x04000000, + ASSEMBLY_FLAGS_TOKEN_MASK = 0x00FFFFFF, + } +#endif // FEATURE_APPX + + private const uint COR_E_LOADING_REFERENCE_ASSEMBLY = 0x80131058U; + + internal RuntimeAssembly() { throw new NotSupportedException(); } + + #region private data members + [method: System.Security.SecurityCritical] + private event ModuleResolveEventHandler _ModuleResolve; + private string m_fullname; + private object m_syncRoot; // Used to keep collectible types alive and as the syncroot for reflection.emit + private IntPtr m_assembly; // slack for ptr datum on unmanaged side + +#if FEATURE_APPX + private ASSEMBLY_FLAGS m_flags; +#endif + #endregion + +#if FEATURE_APPX + internal int InvocableAttributeCtorToken + { + get + { + int token = (int)(Flags & ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_TOKEN_MASK); + + return token | (int)MetadataTokenType.MethodDef; + } + } + + private ASSEMBLY_FLAGS Flags + { + [SecuritySafeCritical] + get + { + if ((m_flags & ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_INITIALIZED) == 0) + { + ASSEMBLY_FLAGS flags = ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_UNKNOWN; + +#if !FEATURE_CORECLR + if (RuntimeAssembly.IsFrameworkAssembly(GetName())) +#else + if (IsProfileAssembly) +#endif + { + flags |= ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_FRAMEWORK | ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_SAFE_REFLECTION; + + foreach (string name in s_unsafeFrameworkAssemblyNames) + { + if (String.Compare(GetSimpleName(), name, StringComparison.OrdinalIgnoreCase) == 0) + { + flags &= ~ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_SAFE_REFLECTION; + break; + } + } + + // Each blessed API will be annotated with a "__DynamicallyInvokableAttribute". + // This "__DynamicallyInvokableAttribute" is a type defined in its own assembly. + // So the ctor is always a MethodDef and the type a TypeDef. + // We cache this ctor MethodDef token for faster custom attribute lookup. + // If this attribute type doesn't exist in the assembly, it means the assembly + // doesn't contain any blessed APIs. + Type invocableAttribute = GetType("__DynamicallyInvokableAttribute", false); + if (invocableAttribute != null) + { + Contract.Assert(((MetadataToken)invocableAttribute.MetadataToken).IsTypeDef); + + ConstructorInfo ctor = invocableAttribute.GetConstructor(Type.EmptyTypes); + Contract.Assert(ctor != null); + + int token = ctor.MetadataToken; + Contract.Assert(((MetadataToken)token).IsMethodDef); + + flags |= (ASSEMBLY_FLAGS)token & ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_TOKEN_MASK; + } + } + else if (IsDesignerBindingContext()) + { + flags = ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_SAFE_REFLECTION; + } + + m_flags = flags | ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_INITIALIZED; + } + + return m_flags; + } + } +#endif // FEATURE_APPX + + internal object SyncRoot + { + get + { + if (m_syncRoot == null) + { + Interlocked.CompareExchange<object>(ref m_syncRoot, new object(), null); + } + return m_syncRoot; + } + } + + public override event ModuleResolveEventHandler ModuleResolve + { + [System.Security.SecurityCritical] // auto-generated_required + add + { + _ModuleResolve += value; + } + [System.Security.SecurityCritical] // auto-generated_required + remove + { + _ModuleResolve -= value; + } + } + + private const String s_localFilePrefix = "file:"; + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetCodeBase(RuntimeAssembly assembly, + bool copiedName, + StringHandleOnStack retString); + + [System.Security.SecurityCritical] // auto-generated + internal String GetCodeBase(bool copiedName) + { + String codeBase = null; + GetCodeBase(GetNativeHandle(), copiedName, JitHelpers.GetStringHandleOnStack(ref codeBase)); + return codeBase; + } + + public override String CodeBase + { +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + get { + String codeBase = GetCodeBase(false); + VerifyCodeBaseDiscovery(codeBase); + return codeBase; + } + } + + internal RuntimeAssembly GetNativeHandle() + { + return this; + } + + // If the assembly is copied before it is loaded, the codebase will be set to the + // actual file loaded if copiedName is true. If it is false, then the original code base + // is returned. +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + public override AssemblyName GetName(bool copiedName) + { + AssemblyName an = new AssemblyName(); + + String codeBase = GetCodeBase(copiedName); + VerifyCodeBaseDiscovery(codeBase); + + an.Init(GetSimpleName(), + GetPublicKey(), + null, // public key token + GetVersion(), + GetLocale(), + GetHashAlgorithm(), + AssemblyVersionCompatibility.SameMachine, + codeBase, + GetFlags() | AssemblyNameFlags.PublicKey, + null); // strong name key pair + + PortableExecutableKinds pek; + ImageFileMachine ifm; + + Module manifestModule = ManifestModule; + if (manifestModule != null) + { + if (manifestModule.MDStreamVersion > 0x10000) + { + ManifestModule.GetPEKind(out pek, out ifm); + an.SetProcArchIndex(pek,ifm); + } + } + return an; + } + +#if FEATURE_APTCA + // This method is called from the VM when creating conditional APTCA exceptions, in order to include + // the text which must be added to the partial trust visible assembly list + [SecurityCritical] + [PermissionSet(SecurityAction.Assert, Unrestricted = true)] + private string GetNameForConditionalAptca() + { + AssemblyName assemblyName = GetName(); + return assemblyName.GetNameWithPublicKey(); + + } +#endif // FEATURE_APTCA + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetFullName(RuntimeAssembly assembly, StringHandleOnStack retString); + + public override String FullName + { + [System.Security.SecuritySafeCritical] // auto-generated + get { + // If called by Object.ToString(), return val may be NULL. + if (m_fullname == null) + { + string s = null; + GetFullName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref s)); + Interlocked.CompareExchange<string>(ref m_fullname, s, null); + } + + return m_fullname; + } + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetEntryPoint(RuntimeAssembly assembly, ObjectHandleOnStack retMethod); + + public override MethodInfo EntryPoint + { + [System.Security.SecuritySafeCritical] // auto-generated + get { + IRuntimeMethodInfo methodHandle = null; + GetEntryPoint(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref methodHandle)); + + if (methodHandle == null) + return null; + + return (MethodInfo)RuntimeType.GetMethodBase(methodHandle); + } + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetType(RuntimeAssembly assembly, + String name, + bool throwOnError, + bool ignoreCase, + ObjectHandleOnStack type); + + [System.Security.SecuritySafeCritical] + public override Type GetType(String name, bool throwOnError, bool ignoreCase) + { + // throw on null strings regardless of the value of "throwOnError" + if (name == null) + throw new ArgumentNullException("name"); + + RuntimeType type = null; + GetType(GetNativeHandle(), name, throwOnError, ignoreCase, JitHelpers.GetObjectHandleOnStack(ref type)); + return type; + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + internal extern static void GetForwardedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes); + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetExportedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes); + + [System.Security.SecuritySafeCritical] // auto-generated + public override Type[] GetExportedTypes() + { + Type[] types = null; + GetExportedTypes(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types)); + return types; + } + + public override IEnumerable<TypeInfo> DefinedTypes + { + [System.Security.SecuritySafeCritical] + get + { + List<RuntimeType> rtTypes = new List<RuntimeType>(); + + RuntimeModule[] modules = GetModulesInternal(true, false); + + for (int i = 0; i < modules.Length; i++) + { + rtTypes.AddRange(modules[i].GetDefinedTypes()); + } + + return rtTypes.ToArray(); + } + } + + // Load a resource based on the NameSpace of the type. + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public override Stream GetManifestResourceStream(Type type, String name) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return GetManifestResourceStream(type, name, false, ref stackMark); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public override Stream GetManifestResourceStream(String name) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return GetManifestResourceStream(name, ref stackMark, false); + } + +#if FEATURE_CAS_POLICY + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetEvidence(RuntimeAssembly assembly, ObjectHandleOnStack retEvidence); + + [SecurityCritical] + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static SecurityRuleSet GetSecurityRuleSet(RuntimeAssembly assembly); + + public override Evidence Evidence + { + [SecuritySafeCritical] + [SecurityPermissionAttribute( SecurityAction.Demand, ControlEvidence = true )] + get + { + Evidence evidence = EvidenceNoDemand; + return evidence.Clone(); + } + } + + internal Evidence EvidenceNoDemand + { + [SecurityCritical] + get + { + Evidence evidence = null; + GetEvidence(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref evidence)); + return evidence; + } + } + + public override PermissionSet PermissionSet + { + [SecurityCritical] + get + { + PermissionSet grantSet = null; + PermissionSet deniedSet = null; + + GetGrantSet(out grantSet, out deniedSet); + + if (grantSet != null) + { + return grantSet.Copy(); + } + else + { + return new PermissionSet(PermissionState.Unrestricted); + } + } + } + + public override SecurityRuleSet SecurityRuleSet + { + [SecuritySafeCritical] + get + { + return GetSecurityRuleSet(GetNativeHandle()); + } + } +#endif // FEATURE_CAS_POLICY + + // ISerializable implementation + [System.Security.SecurityCritical] // auto-generated_required + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + if (info==null) + throw new ArgumentNullException("info"); + + Contract.EndContractBlock(); + + UnitySerializationHolder.GetUnitySerializationInfo(info, + UnitySerializationHolder.AssemblyUnity, + this.FullName, + this); + } + + public override Module ManifestModule + { + get + { + // We don't need to return the "external" ModuleBuilder because + // it is meant to be read-only + return RuntimeAssembly.GetManifestModule(GetNativeHandle()); + } + } + + public override Object[] GetCustomAttributes(bool inherit) + { + return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType); + } + + public override Object[] GetCustomAttributes(Type attributeType, bool inherit) + { + if (attributeType == null) + throw new ArgumentNullException("attributeType"); + Contract.EndContractBlock(); + + RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType; + + if (attributeRuntimeType == null) + throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"),"attributeType"); + + return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType); + } + + public override bool IsDefined(Type attributeType, bool inherit) + { + if (attributeType == null) + throw new ArgumentNullException("attributeType"); + Contract.EndContractBlock(); + + RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType; + + if (attributeRuntimeType == null) + throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"),"caType"); + + return CustomAttribute.IsDefined(this, attributeRuntimeType); + } + + public override IList<CustomAttributeData> GetCustomAttributesData() + { + return CustomAttributeData.GetCustomAttributesInternal(this); + } + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + internal static RuntimeAssembly InternalLoadFrom(String assemblyFile, + Evidence securityEvidence, + byte[] hashValue, + AssemblyHashAlgorithm hashAlgorithm, + bool forIntrospection, + bool suppressSecurityChecks, + ref StackCrawlMark stackMark) + { + if (assemblyFile == null) + throw new ArgumentNullException("assemblyFile"); + + Contract.EndContractBlock(); + +#if FEATURE_CAS_POLICY + if (securityEvidence != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled) + { + throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit")); + } +#endif // FEATURE_CAS_POLICY + AssemblyName an = new AssemblyName(); + an.CodeBase = assemblyFile; + an.SetHashControl(hashValue, hashAlgorithm); + // The stack mark is used for MDA filtering + return InternalLoadAssemblyName(an, securityEvidence, null, ref stackMark, true /*thrownOnFileNotFound*/, forIntrospection, suppressSecurityChecks); + } + +#if FEATURE_HOSTED_BINDER + // Wrapper function to wrap the typical use of InternalLoad. Matches exactly with the signature below if FEATURE_HOSTED_BINDER is not set + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly InternalLoad(String assemblyString, + Evidence assemblySecurity, + ref StackCrawlMark stackMark, + bool forIntrospection) + { + return InternalLoad(assemblyString, assemblySecurity, ref stackMark, IntPtr.Zero, forIntrospection); + } +#endif + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + internal static RuntimeAssembly InternalLoad(String assemblyString, + Evidence assemblySecurity, + ref StackCrawlMark stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr pPrivHostBinder, +#endif + bool forIntrospection) + { + RuntimeAssembly assembly; + AssemblyName an = CreateAssemblyName(assemblyString, forIntrospection, out assembly); + + if (assembly != null) { + // The assembly was returned from ResolveAssemblyEvent + return assembly; + } + + return InternalLoadAssemblyName(an, assemblySecurity, null, ref stackMark, +#if FEATURE_HOSTED_BINDER + pPrivHostBinder, +#endif + true /*thrownOnFileNotFound*/, forIntrospection, false /* suppressSecurityChecks */); + } + + // Creates AssemblyName. Fills assembly if AssemblyResolve event has been raised. + [System.Security.SecurityCritical] // auto-generated + internal static AssemblyName CreateAssemblyName( + String assemblyString, + bool forIntrospection, + out RuntimeAssembly assemblyFromResolveEvent) + { + if (assemblyString == null) + throw new ArgumentNullException("assemblyString"); + Contract.EndContractBlock(); + + if ((assemblyString.Length == 0) || + (assemblyString[0] == '\0')) + throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength")); + + if (forIntrospection) + AppDomain.CheckReflectionOnlyLoadSupported(); + + AssemblyName an = new AssemblyName(); + + an.Name = assemblyString; + an.nInit(out assemblyFromResolveEvent, forIntrospection, true); + + return an; + } + +#if FEATURE_HOSTED_BINDER + // Wrapper function to wrap the typical use of InternalLoadAssemblyName. Matches exactly with the signature below if FEATURE_HOSTED_BINDER is not set + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly InternalLoadAssemblyName( + AssemblyName assemblyRef, + Evidence assemblySecurity, + RuntimeAssembly reqAssembly, + ref StackCrawlMark stackMark, + bool throwOnFileNotFound, + bool forIntrospection, + bool suppressSecurityChecks) + { + return InternalLoadAssemblyName(assemblyRef, assemblySecurity, reqAssembly, ref stackMark, IntPtr.Zero, true /*throwOnError*/, forIntrospection, suppressSecurityChecks); + } +#endif + + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly InternalLoadAssemblyName( + AssemblyName assemblyRef, + Evidence assemblySecurity, + RuntimeAssembly reqAssembly, + ref StackCrawlMark stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr pPrivHostBinder, +#endif + bool throwOnFileNotFound, + bool forIntrospection, + bool suppressSecurityChecks) + { + + if (assemblyRef == null) + throw new ArgumentNullException("assemblyRef"); + Contract.EndContractBlock(); + + if (assemblyRef.CodeBase != null) + { + AppDomain.CheckLoadFromSupported(); + } + + assemblyRef = (AssemblyName)assemblyRef.Clone(); +#if FEATURE_VERSIONING + if (!forIntrospection && + (assemblyRef.ProcessorArchitecture != ProcessorArchitecture.None)) { + // PA does not have a semantics for by-name binds for execution + assemblyRef.ProcessorArchitecture = ProcessorArchitecture.None; + } +#endif + + if (assemblySecurity != null) + { +#if FEATURE_CAS_POLICY + if (!AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled) + { + throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit")); + } +#endif // FEATURE_CAS_POLICY + + if (!suppressSecurityChecks) + { +#pragma warning disable 618 + new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand(); +#pragma warning restore 618 + } + } + + + String codeBase = VerifyCodeBase(assemblyRef.CodeBase); + if (codeBase != null && !suppressSecurityChecks) { + + if (String.Compare( codeBase, 0, s_localFilePrefix, 0, 5, StringComparison.OrdinalIgnoreCase) != 0) { +#if FEATURE_FUSION // Of all the binders, Fusion is the only one that understands Web locations + IPermission perm = CreateWebPermission( assemblyRef.EscapedCodeBase ); + perm.Demand(); +#else + throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "assemblyRef.CodeBase"); +#endif + } + else { + System.Security.Util.URLString urlString = new System.Security.Util.URLString( codeBase, true ); + new FileIOPermission( FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read , urlString.GetFileName() ).Demand(); + } + } + + return nLoad(assemblyRef, codeBase, assemblySecurity, reqAssembly, ref stackMark, +#if FEATURE_HOSTED_BINDER + pPrivHostBinder, +#endif + throwOnFileNotFound, forIntrospection, suppressSecurityChecks); + } + + // These are the framework assemblies that does reflection invocation + // on behalf of user code. We allow framework code to invoke non-W8P + // framework APIs but don't want user code to gain that privilege + // through these assemblies. So we blaklist them. + static string[] s_unsafeFrameworkAssemblyNames = new string[] { + "System.Reflection.Context", + "Microsoft.VisualBasic" + }; + +#if FEATURE_APPX + [System.Security.SecuritySafeCritical] + internal bool IsFrameworkAssembly() + { + ASSEMBLY_FLAGS flags = Flags; + return (flags & ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_FRAMEWORK) != 0; + } + + // Returns true if we want to allow this assembly to invoke non-W8P + // framework APIs through reflection. + internal bool IsSafeForReflection() + { + ASSEMBLY_FLAGS flags = Flags; + return (flags & ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_SAFE_REFLECTION) != 0; + } + + [System.Security.SecuritySafeCritical] + private bool IsDesignerBindingContext() + { + return RuntimeAssembly.nIsDesignerBindingContext(this); + } + + [System.Security.SecurityCritical] + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static bool nIsDesignerBindingContext(RuntimeAssembly assembly); +#endif + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private static extern RuntimeAssembly _nLoad(AssemblyName fileName, + String codeBase, + Evidence assemblySecurity, + RuntimeAssembly locationHint, + ref StackCrawlMark stackMark, + +#if FEATURE_HOSTED_BINDER + IntPtr pPrivHostBinder, +#endif + bool throwOnFileNotFound, + bool forIntrospection, + bool suppressSecurityChecks); + +#if !FEATURE_CORECLR + // The NGEN task uses this method, so please do not modify its signature + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private static extern bool IsFrameworkAssembly(AssemblyName assemblyName); + + [System.Security.SecurityCritical] + [MethodImplAttribute(MethodImplOptions.InternalCall)] + internal static extern bool IsNewPortableAssembly(AssemblyName assemblyName); +#endif + + [System.Security.SecurityCritical] // auto-generated + private static RuntimeAssembly nLoad(AssemblyName fileName, + String codeBase, + Evidence assemblySecurity, + RuntimeAssembly locationHint, + ref StackCrawlMark stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr pPrivHostBinder, +#endif + bool throwOnFileNotFound, + bool forIntrospection, + bool suppressSecurityChecks) + { + return _nLoad(fileName, codeBase, assemblySecurity, locationHint, ref stackMark, +#if FEATURE_HOSTED_BINDER + pPrivHostBinder, +#endif + throwOnFileNotFound, forIntrospection, suppressSecurityChecks); + } + +#if FEATURE_FUSION + // used by vm + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + private static unsafe RuntimeAssembly LoadWithPartialNameHack(String partialName, bool cropPublicKey) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + + AssemblyName an = new AssemblyName(partialName); + + if (!IsSimplyNamed(an)) + { + if (cropPublicKey) + { + an.SetPublicKey(null); + an.SetPublicKeyToken(null); + } + + if(IsFrameworkAssembly(an) || !AppDomain.IsAppXModel()) + { + AssemblyName GACAssembly = EnumerateCache(an); + if(GACAssembly != null) + return InternalLoadAssemblyName(GACAssembly, null, null,ref stackMark, true /*thrownOnFileNotFound*/, false, false); + else + return null; + } + } + + if (AppDomain.IsAppXModel()) + { + // also try versionless bind from the package + an.Version = null; + return nLoad(an, null, null, null, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + false, false, false); + } + return null; + + } + +#if !FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly LoadWithPartialNameInternal(String partialName, Evidence securityEvidence, ref StackCrawlMark stackMark) + { + AssemblyName an = new AssemblyName(partialName); + return LoadWithPartialNameInternal(an, securityEvidence, ref stackMark); + } + + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly LoadWithPartialNameInternal(AssemblyName an, Evidence securityEvidence, ref StackCrawlMark stackMark) + { + if (securityEvidence != null) + { +#if FEATURE_CAS_POLICY + if (!AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled) + { + throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit")); + } +#endif // FEATURE_CAS_POLICY + new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand(); + } + + AppDomain.CheckLoadWithPartialNameSupported(stackMark); + + RuntimeAssembly result = null; + try { + result = nLoad(an, null, securityEvidence, null, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + true, false, false); + } + catch(Exception e) { + if (e.IsTransient) + throw e; + + if (IsUserError(e)) + throw; + + + if(IsFrameworkAssembly(an) || !AppDomain.IsAppXModel()) + { + if (IsSimplyNamed(an)) + return null; + + AssemblyName GACAssembly = EnumerateCache(an); + if(GACAssembly != null) + result = InternalLoadAssemblyName(GACAssembly, securityEvidence, null, ref stackMark, true /*thrownOnFileNotFound*/, false, false); + } + else + { + an.Version = null; + result = nLoad(an, null, securityEvidence, null, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + false, false, false); + } + } + + + return result; + } +#endif // !FEATURE_CORECLR + + [SecuritySafeCritical] + private static bool IsUserError(Exception e) + { + return (uint)e.HResult == COR_E_LOADING_REFERENCE_ASSEMBLY; + } + + private static bool IsSimplyNamed(AssemblyName partialName) + { + byte[] pk = partialName.GetPublicKeyToken(); + if ((pk != null) && + (pk.Length == 0)) + return true; + + pk = partialName.GetPublicKey(); + if ((pk != null) && + (pk.Length == 0)) + return true; + + return false; + } + + [System.Security.SecurityCritical] // auto-generated + private static AssemblyName EnumerateCache(AssemblyName partialName) + { + new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); + + partialName.Version = null; + + ArrayList a = new ArrayList(); + Fusion.ReadCache(a, partialName.FullName, ASM_CACHE.GAC); + + IEnumerator myEnum = a.GetEnumerator(); + AssemblyName ainfoBest = null; + CultureInfo refCI = partialName.CultureInfo; + + while (myEnum.MoveNext()) { + AssemblyName ainfo = new AssemblyName((String)myEnum.Current); + + if (CulturesEqual(refCI, ainfo.CultureInfo)) { + if (ainfoBest == null) + ainfoBest = ainfo; + else { + // Choose highest version + if (ainfo.Version > ainfoBest.Version) + ainfoBest = ainfo; + } + } + } + + return ainfoBest; + } + + private static bool CulturesEqual(CultureInfo refCI, CultureInfo defCI) + { + bool defNoCulture = defCI.Equals(CultureInfo.InvariantCulture); + + // cultured asms aren't allowed to be bound to if + // the ref doesn't ask for them specifically + if ((refCI == null) || refCI.Equals(CultureInfo.InvariantCulture)) + return defNoCulture; + + if (defNoCulture || + ( !defCI.Equals(refCI) )) + return false; + + return true; + } +#endif // FEATURE_FUSION + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private static extern bool IsReflectionOnly(RuntimeAssembly assembly); + + // To not break compatibility with the V1 _Assembly interface we need to make this + // new member ComVisible(false). + [ComVisible(false)] + public override bool ReflectionOnly + { + [System.Security.SecuritySafeCritical] // auto-generated + get + { + return IsReflectionOnly(GetNativeHandle()); + } + } + +#if FEATURE_CORECLR + // Loads the assembly with a COFF based IMAGE containing + // an emitted assembly. The assembly is loaded into the domain + // of the caller. Currently is implemented only for UnmanagedMemoryStream + // (no derived classes since we are not calling Read()) + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly InternalLoadFromStream(Stream assemblyStream, Stream pdbStream, ref StackCrawlMark stackMark) + { + if (assemblyStream == null) + throw new ArgumentNullException("assemblyStream"); + + if (assemblyStream.GetType()!=typeof(UnmanagedMemoryStream)) + throw new NotSupportedException(); + + if (pdbStream!= null && pdbStream.GetType()!=typeof(UnmanagedMemoryStream)) + throw new NotSupportedException(); + + AppDomain.CheckLoadFromSupported(); + + UnmanagedMemoryStream umAssemblyStream = (UnmanagedMemoryStream)assemblyStream; + UnmanagedMemoryStream umPdbStream = (UnmanagedMemoryStream)pdbStream; + + unsafe + { + byte* umAssemblyStreamBuffer=umAssemblyStream.PositionPointer; + byte* umPdbStreamBuffer=(umPdbStream!=null)?umPdbStream.PositionPointer:null; + long assemblyDataLength = umAssemblyStream.Length-umAssemblyStream.Position; + long pdbDataLength = (umPdbStream!=null)?(umPdbStream.Length-umPdbStream.Position):0; + + // use Seek() to benefit from boundary checking, the actual read is done using *StreamBuffer + umAssemblyStream.Seek(assemblyDataLength,SeekOrigin.Current); + + if(umPdbStream != null) + { + umPdbStream.Seek(pdbDataLength,SeekOrigin.Current); + } + + BCLDebug.Assert(assemblyDataLength > 0L, "assemblyDataLength > 0L"); + + RuntimeAssembly assembly = null; + + nLoadFromUnmanagedArray(false, + umAssemblyStreamBuffer, + (ulong)assemblyDataLength, + umPdbStreamBuffer, + (ulong)pdbDataLength, + JitHelpers.GetStackCrawlMarkHandle(ref stackMark), + JitHelpers.GetObjectHandleOnStack(ref assembly)); + + return assembly; + } + } +#endif //FEATURE_CORECLR + +#if FEATURE_MULTIMODULE_ASSEMBLIES + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void LoadModule(RuntimeAssembly assembly, + String moduleName, + byte[] rawModule, int cbModule, + byte[] rawSymbolStore, int cbSymbolStore, + ObjectHandleOnStack retModule); + + [SecurityPermissionAttribute(SecurityAction.Demand, ControlEvidence = true)] + [System.Security.SecuritySafeCritical] // auto-generated + public override Module LoadModule(String moduleName, byte[] rawModule, byte[] rawSymbolStore) + { + RuntimeModule retModule = null; + LoadModule( + GetNativeHandle(), + moduleName, + rawModule, + (rawModule != null) ? rawModule.Length : 0, + rawSymbolStore, + (rawSymbolStore != null) ? rawSymbolStore.Length : 0, + JitHelpers.GetObjectHandleOnStack(ref retModule)); + + return retModule; + } +#endif //FEATURE_MULTIMODULE_ASSEMBLIES + + // Returns the module in this assembly with name 'name' + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetModule(RuntimeAssembly assembly, String name, ObjectHandleOnStack retModule); + + [System.Security.SecuritySafeCritical] // auto-generated + public override Module GetModule(String name) + { + Module retModule = null; + GetModule(GetNativeHandle(), name, JitHelpers.GetObjectHandleOnStack(ref retModule)); + return retModule; + } + + // Returns the file in the File table of the manifest that matches the + // given name. (Name should not include path.) +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + public override FileStream GetFile(String name) + { + RuntimeModule m = (RuntimeModule)GetModule(name); + if (m == null) + return null; + + return new FileStream(m.GetFullyQualifiedName(), + FileMode.Open, + FileAccess.Read, FileShare.Read, FileStream.DefaultBufferSize, false); + } + +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + public override FileStream[] GetFiles(bool getResourceModules) + { + Module[] m = GetModules(getResourceModules); + int iLength = m.Length; + FileStream[] fs = new FileStream[iLength]; + + for(int i = 0; i < iLength; i++) + fs[i] = new FileStream(((RuntimeModule)m[i]).GetFullyQualifiedName(), + FileMode.Open, + FileAccess.Read, FileShare.Read, FileStream.DefaultBufferSize, false); + + return fs; + } + + + // Returns the names of all the resources + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private static extern String[] GetManifestResourceNames(RuntimeAssembly assembly); + + // Returns the names of all the resources + [System.Security.SecuritySafeCritical] // auto-generated + public override String[] GetManifestResourceNames() + { + return GetManifestResourceNames(GetNativeHandle()); + } + + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetExecutingAssembly(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly); + + [System.Security.SecurityCritical] // auto-generated + internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark) + { + RuntimeAssembly retAssembly = null; + GetExecutingAssembly(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly)); + return retAssembly; + } + + // Returns the names of all the resources + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private static extern AssemblyName[] GetReferencedAssemblies(RuntimeAssembly assembly); + + [System.Security.SecuritySafeCritical] // auto-generated + public override AssemblyName[] GetReferencedAssemblies() + { + return GetReferencedAssemblies(GetNativeHandle()); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern int GetManifestResourceInfo(RuntimeAssembly assembly, + String resourceName, + ObjectHandleOnStack assemblyRef, + StringHandleOnStack retFileName, + StackCrawlMarkHandle stackMark); + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public override ManifestResourceInfo GetManifestResourceInfo(String resourceName) + { + RuntimeAssembly retAssembly = null; + String fileName = null; + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + int location = GetManifestResourceInfo(GetNativeHandle(), resourceName, + JitHelpers.GetObjectHandleOnStack(ref retAssembly), + JitHelpers.GetStringHandleOnStack(ref fileName), + JitHelpers.GetStackCrawlMarkHandle(ref stackMark)); + + if (location == -1) + return null; + + return new ManifestResourceInfo(retAssembly, fileName, + (ResourceLocation) location); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetLocation(RuntimeAssembly assembly, StringHandleOnStack retString); + + public override String Location + { +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated +#else + [System.Security.SecuritySafeCritical] +#endif + get { + String location = null; + + GetLocation(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref location)); + + if (location != null) + new FileIOPermission( FileIOPermissionAccess.PathDiscovery, location ).Demand(); + + return location; + } + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetImageRuntimeVersion(RuntimeAssembly assembly, StringHandleOnStack retString); + + // To not break compatibility with the V1 _Assembly interface we need to make this + // new member ComVisible(false). + [ComVisible(false)] + public override String ImageRuntimeVersion + { + [System.Security.SecuritySafeCritical] // auto-generated + get{ + String s = null; + GetImageRuntimeVersion(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref s)); + return s; + } + } + + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private extern static bool IsGlobalAssemblyCache(RuntimeAssembly assembly); + + public override bool GlobalAssemblyCache + { + [System.Security.SecuritySafeCritical] // auto-generated + get + { + return IsGlobalAssemblyCache(GetNativeHandle()); + } + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static Int64 GetHostContext(RuntimeAssembly assembly); + + public override Int64 HostContext + { + [System.Security.SecuritySafeCritical] // auto-generated + get + { + return GetHostContext(GetNativeHandle()); + } + } + + private static String VerifyCodeBase(String codebase) + { + if(codebase == null) + return null; + + int len = codebase.Length; + if (len == 0) + return null; + + + int j = codebase.IndexOf(':'); + // Check to see if the url has a prefix + if( (j != -1) && + (j+2 < len) && + ((codebase[j+1] == '/') || (codebase[j+1] == '\\')) && + ((codebase[j+2] == '/') || (codebase[j+2] == '\\')) ) + return codebase; +#if !PLATFORM_UNIX + else if ((len > 2) && (codebase[0] == '\\') && (codebase[1] == '\\')) + return "file://" + codebase; + else + return "file:///" + Path.GetFullPathInternal( codebase ); +#else + else + return "file://" + Path.GetFullPathInternal( codebase ); +#endif // !PLATFORM_UNIX + } + + [System.Security.SecurityCritical] // auto-generated + internal Stream GetManifestResourceStream( + Type type, + String name, + bool skipSecurityCheck, + ref StackCrawlMark stackMark) + { + StringBuilder sb = new StringBuilder(); + if(type == null) { + if (name == null) + throw new ArgumentNullException("type"); + } + else { + String nameSpace = type.Namespace; + if(nameSpace != null) { + sb.Append(nameSpace); + if(name != null) + sb.Append(Type.Delimiter); + } + } + + if(name != null) + sb.Append(name); + + return GetManifestResourceStream(sb.ToString(), ref stackMark, skipSecurityCheck); + } + +#if FEATURE_CAS_POLICY + internal bool IsStrongNameVerified + { + [System.Security.SecurityCritical] // auto-generated + get { return GetIsStrongNameVerified(GetNativeHandle()); } + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern bool GetIsStrongNameVerified(RuntimeAssembly assembly); +#endif // FEATURE_CAS_POLICY + + // GetResource will return a pointer to the resources in memory. + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static unsafe extern byte* GetResource(RuntimeAssembly assembly, + String resourceName, + out ulong length, + StackCrawlMarkHandle stackMark, + bool skipSecurityCheck); + + [System.Security.SecurityCritical] // auto-generated + internal unsafe Stream GetManifestResourceStream(String name, ref StackCrawlMark stackMark, bool skipSecurityCheck) + { + ulong length = 0; + byte* pbInMemoryResource = GetResource(GetNativeHandle(), name, out length, JitHelpers.GetStackCrawlMarkHandle(ref stackMark), skipSecurityCheck); + + if (pbInMemoryResource != null) { + //Console.WriteLine("Creating an unmanaged memory stream of length "+length); + if (length > Int64.MaxValue) + throw new NotImplementedException(Environment.GetResourceString("NotImplemented_ResourcesLongerThan2^63")); + + return new UnmanagedMemoryStream(pbInMemoryResource, (long)length, (long)length, FileAccess.Read, true); + } + + //Console.WriteLine("GetManifestResourceStream: Blob "+name+" not found..."); + return null; + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetVersion(RuntimeAssembly assembly, + out int majVer, + out int minVer, + out int buildNum, + out int revNum); + + [System.Security.SecurityCritical] // auto-generated + internal Version GetVersion() + { + int majorVer, minorVer, build, revision; + GetVersion(GetNativeHandle(), out majorVer, out minorVer, out build, out revision); + return new Version (majorVer, minorVer, build, revision); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetLocale(RuntimeAssembly assembly, StringHandleOnStack retString); + + [System.Security.SecurityCritical] // auto-generated + internal CultureInfo GetLocale() + { + String locale = null; + + GetLocale(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref locale)); + + if (locale == null) + return CultureInfo.InvariantCulture; + + return new CultureInfo(locale); + } + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + private static extern bool FCallIsDynamic(RuntimeAssembly assembly); + + public override bool IsDynamic + { + [SecuritySafeCritical] + get { + return FCallIsDynamic(GetNativeHandle()); + } + } + + [System.Security.SecurityCritical] // auto-generated + private void VerifyCodeBaseDiscovery(String codeBase) + { +#if FEATURE_CAS_POLICY + if (CodeAccessSecurityEngine.QuickCheckForAllDemands()) { + return; + } +#endif // FEATURE_CAS_POLICY + + if ((codeBase != null) && + (String.Compare( codeBase, 0, s_localFilePrefix, 0, 5, StringComparison.OrdinalIgnoreCase) == 0)) { + System.Security.Util.URLString urlString = new System.Security.Util.URLString( codeBase, true ); + new FileIOPermission( FileIOPermissionAccess.PathDiscovery, urlString.GetFileName() ).Demand(); + } + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetSimpleName(RuntimeAssembly assembly, StringHandleOnStack retSimpleName); + + [SecuritySafeCritical] + internal String GetSimpleName() + { + string name = null; + GetSimpleName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref name)); + return name; + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static AssemblyHashAlgorithm GetHashAlgorithm(RuntimeAssembly assembly); + + [System.Security.SecurityCritical] // auto-generated + private AssemblyHashAlgorithm GetHashAlgorithm() + { + return GetHashAlgorithm(GetNativeHandle()); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static AssemblyNameFlags GetFlags(RuntimeAssembly assembly); + + [System.Security.SecurityCritical] // auto-generated + private AssemblyNameFlags GetFlags() + { + return GetFlags(GetNativeHandle()); + } + + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SecurityCritical] + [SuppressUnmanagedCodeSecurity] + private static extern void GetRawBytes(RuntimeAssembly assembly, ObjectHandleOnStack retRawBytes); + + // Get the raw bytes of the assembly + [SecuritySafeCritical] + internal byte[] GetRawBytes() + { + byte[] rawBytes = null; + + GetRawBytes(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref rawBytes)); + return rawBytes; + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private static extern void GetPublicKey(RuntimeAssembly assembly, ObjectHandleOnStack retPublicKey); + + [System.Security.SecurityCritical] // auto-generated + internal byte[] GetPublicKey() + { + byte[] publicKey = null; + GetPublicKey(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref publicKey)); + return publicKey; + } + + [SecurityCritical] + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetGrantSet(RuntimeAssembly assembly, ObjectHandleOnStack granted, ObjectHandleOnStack denied); + + [SecurityCritical] + internal void GetGrantSet(out PermissionSet newGrant, out PermissionSet newDenied) + { + PermissionSet granted = null, denied = null; + GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref granted), JitHelpers.GetObjectHandleOnStack(ref denied)); + newGrant = granted; newDenied = denied; + } + +#if FEATURE_LEGACYNETCF + [System.Security.SecurityCritical] + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + internal static extern bool GetIsProfileAssembly(RuntimeAssembly assembly); + + // True if the assembly is a trusted platform assembly + internal override bool IsProfileAssembly + { + [System.Security.SecurityCritical] + get + { + return GetIsProfileAssembly(GetNativeHandle()); + } + } +#endif // FEATURE_LEGACYNETCF + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + private extern static bool IsAllSecurityCritical(RuntimeAssembly assembly); + + // Is everything introduced by this assembly critical + [System.Security.SecuritySafeCritical] // auto-generated + internal bool IsAllSecurityCritical() + { + return IsAllSecurityCritical(GetNativeHandle()); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + private extern static bool IsAllSecuritySafeCritical(RuntimeAssembly assembly); + + // Is everything introduced by this assembly safe critical + [System.Security.SecuritySafeCritical] // auto-generated + internal bool IsAllSecuritySafeCritical() + { + return IsAllSecuritySafeCritical(GetNativeHandle()); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + private extern static bool IsAllPublicAreaSecuritySafeCritical(RuntimeAssembly assembly); + + // Is everything introduced by this assembly safe critical + [System.Security.SecuritySafeCritical] // auto-generated + internal bool IsAllPublicAreaSecuritySafeCritical() + { + return IsAllPublicAreaSecuritySafeCritical(GetNativeHandle()); + } + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + private extern static bool IsAllSecurityTransparent(RuntimeAssembly assembly); + + // Is everything introduced by this assembly transparent + [System.Security.SecuritySafeCritical] // auto-generated + internal bool IsAllSecurityTransparent() + { + return IsAllSecurityTransparent(GetNativeHandle()); + } + +#if FEATURE_FUSION + // demandFlag: + // 0 demand PathDiscovery permission only + // 1 demand Read permission only + // 2 demand both Read and PathDiscovery + // 3 demand Web permission only + [System.Security.SecurityCritical] // auto-generated + private static void DemandPermission(String codeBase, bool havePath, + int demandFlag) + { + FileIOPermissionAccess access = FileIOPermissionAccess.PathDiscovery; + switch(demandFlag) { + + case 0: // default + break; + case 1: + access = FileIOPermissionAccess.Read; + break; + case 2: + access = FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read; + break; + + case 3: + IPermission perm = CreateWebPermission(AssemblyName.EscapeCodeBase(codeBase)); + perm.Demand(); + return; + } + + if (!havePath) { + System.Security.Util.URLString urlString = new System.Security.Util.URLString( codeBase, true ); + codeBase = urlString.GetFileName(); + } + + codeBase = Path.GetFullPathInternal(codeBase); // canonicalize + + new FileIOPermission(access, codeBase).Demand(); + } +#endif + +#if FEATURE_FUSION + private static IPermission CreateWebPermission( String codeBase ) + { + Contract.Assert( codeBase != null, "Must pass in a valid CodeBase" ); + Assembly sys = Assembly.Load("System, Version=" + ThisAssembly.Version + ", Culture=neutral, PublicKeyToken=" + AssemblyRef.EcmaPublicKeyToken); + + Type type = sys.GetType("System.Net.NetworkAccess", true); + + IPermission retval = null; + if (!type.IsEnum || !type.IsVisible) + goto Exit; + + Object[] webArgs = new Object[2]; + webArgs[0] = (Enum) Enum.Parse(type, "Connect", true); + if (webArgs[0] == null) + goto Exit; + + webArgs[1] = codeBase; + + type = sys.GetType("System.Net.WebPermission", true); + + if (!type.IsVisible) + goto Exit; + + retval = (IPermission) Activator.CreateInstance(type, webArgs); + + Exit: + if (retval == null) { + Contract.Assert( false, "Unable to create WebPermission" ); + throw new InvalidOperationException(); + } + + return retval; + } +#endif + // This method is called by the VM. + [System.Security.SecurityCritical] + private RuntimeModule OnModuleResolveEvent(String moduleName) + { + ModuleResolveEventHandler moduleResolve = _ModuleResolve; + if (moduleResolve == null) + return null; + + Delegate[] ds = moduleResolve.GetInvocationList(); + int len = ds.Length; + for (int i = 0; i < len; i++) { + RuntimeModule ret = (RuntimeModule)((ModuleResolveEventHandler) ds[i])(this, new ResolveEventArgs(moduleName,this)); + if (ret != null) + return ret; + } + + return null; + } + + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public override Assembly GetSatelliteAssembly(CultureInfo culture) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return InternalGetSatelliteAssembly(culture, null, ref stackMark); + } + + // Useful for binding to a very specific version of a satellite assembly + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + public override Assembly GetSatelliteAssembly(CultureInfo culture, Version version) + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return InternalGetSatelliteAssembly(culture, version, ref stackMark); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + internal Assembly InternalGetSatelliteAssembly(CultureInfo culture, + Version version, + ref StackCrawlMark stackMark) + { + if (culture == null) + throw new ArgumentNullException("culture"); + Contract.EndContractBlock(); + + + String name = GetSimpleName() + ".resources"; + return InternalGetSatelliteAssembly(name, culture, version, true, ref stackMark); + } + +#if !FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool UseRelativeBindForSatellites(); +#endif + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + internal RuntimeAssembly InternalGetSatelliteAssembly(String name, + CultureInfo culture, + Version version, + bool throwOnFileNotFound, + ref StackCrawlMark stackMark) + { + + AssemblyName an = new AssemblyName(); + + an.SetPublicKey(GetPublicKey()); + an.Flags = GetFlags() | AssemblyNameFlags.PublicKey; + + if (version == null) + an.Version = GetVersion(); + else + an.Version = version; + + an.CultureInfo = culture; + an.Name = name; + + RuntimeAssembly retAssembly = null; + +#if !FEATURE_CORECLR + bool bIsAppXDevMode = AppDomain.IsAppXDesignMode(); + + bool useRelativeBind = false; + if (CodeAccessSecurityEngine.QuickCheckForAllDemands()) + { + if (IsFrameworkAssembly()) + useRelativeBind = true; + else + useRelativeBind = UseRelativeBindForSatellites(); + } + + + if (bIsAppXDevMode || useRelativeBind) + { + if (GlobalAssemblyCache) + { + // lookup in GAC + ArrayList a = new ArrayList(); + bool bTryLoadAnyway = false; + try + { + Fusion.ReadCache(a, an.FullName, ASM_CACHE.GAC); + } + catch(Exception e) + { + if (e.IsTransient) + throw; + + // We also catch any other exception types we haven't come across yet, + // not just UnauthorizedAccessException. + + // We do not want this by itself to cause us to fail to load resources. + + // On Classic, try the old unoptimized way, for full compatibility with 4.0. + // i.e. fall back to using nLoad. + if (!AppDomain.IsAppXModel()) + bTryLoadAnyway = true; + + // On AppX: + // Do not try nLoad since that would effectively allow Framework + // resource satellite assemblies to be placed in AppX packages. + // Instead, leave retAssembly == null. If we were called by the + // ResourceManager, this will usually result in falling back to + // the next culture in the resource fallback chain, possibly the + // neutral culture. + + // Note: if throwOnFileNotFound is true, arbitrary + // exceptions will be absorbed here and + // FileNotFoundException will be thrown in their place. + // (See below: "throw new FileNotFoundException"). + } + if (a.Count > 0 || bTryLoadAnyway) + { + // present in the GAC, load it from there + retAssembly = nLoad(an, null, null, this, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + throwOnFileNotFound, false, false); + } + } + else + { + String codeBase = CodeBase; + + if ((codeBase != null) && + (String.Compare(codeBase, 0, s_localFilePrefix, 0, 5, StringComparison.OrdinalIgnoreCase) == 0)) + { + retAssembly = InternalProbeForSatelliteAssemblyNextToParentAssembly(an, + name, + codeBase, + culture, + throwOnFileNotFound, + bIsAppXDevMode /* useLoadFile */, // if bIsAppXDevMode is false, then useRelativeBind is true. + ref stackMark); + if (retAssembly != null && !IsSimplyNamed(an)) + { + AssemblyName defName = retAssembly.GetName(); + if (!AssemblyName.ReferenceMatchesDefinitionInternal(an,defName,false)) + retAssembly = null; + } + } + else if (!bIsAppXDevMode) + { + retAssembly = nLoad(an, null, null, this, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + throwOnFileNotFound, false, false); + } + } + } + else +#endif // !FEATURE_CORECLR + { + retAssembly = nLoad(an, null, null, this, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + throwOnFileNotFound, false, false); + } + + if (retAssembly == this || (retAssembly == null && throwOnFileNotFound)) + { +#if FEATURE_LEGACYNETCF + if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) + { + if (retAssembly == this) + { + if (throwOnFileNotFound) + throw new FileNotFoundException(); + return null; + } + } +#endif + throw new FileNotFoundException(String.Format(culture, Environment.GetResourceString("IO.FileNotFound_FileName"), an.Name)); + } + + return retAssembly; + } + + // Helper method used by InternalGetSatelliteAssembly only. Not abstracted for use elsewhere. + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable + private RuntimeAssembly InternalProbeForSatelliteAssemblyNextToParentAssembly(AssemblyName an, + String name, + String codeBase, + CultureInfo culture, + bool throwOnFileNotFound, + bool useLoadFile, + ref StackCrawlMark stackMark) + { + // if useLoadFile == false, we do LoadFrom binds + + RuntimeAssembly retAssembly = null; + String location = null; + + if (useLoadFile) + location = Location; + + FileNotFoundException dllNotFoundException = null; + + StringBuilder assemblyFile = new StringBuilder(useLoadFile ? location : codeBase, + 0, + useLoadFile ? location.LastIndexOf('\\') + 1 : codeBase.LastIndexOf('/') + 1, + Path.MAX_PATH); + assemblyFile.Append(an.CultureInfo.Name); + assemblyFile.Append(useLoadFile ? '\\' : '/'); + assemblyFile.Append(name); + assemblyFile.Append(".DLL"); + + string fileNameOrCodeBase = assemblyFile.ToString(); + + AssemblyName loadFromAsmName = null; + + if (useLoadFile == false) + { + loadFromAsmName = new AssemblyName(); + // set just the codebase - we want this to be a pure LoadFrom + loadFromAsmName.CodeBase = fileNameOrCodeBase; + } + + try + { + try + { + retAssembly = useLoadFile ? nLoadFile(fileNameOrCodeBase, null) : + nLoad(loadFromAsmName, fileNameOrCodeBase, null, this, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + throwOnFileNotFound, false, false); + } + catch (FileNotFoundException) + { + // Create our own exception since the one caught doesn't have a filename associated with it, making it less useful for debugging. + dllNotFoundException = new FileNotFoundException(String.Format(culture, + Environment.GetResourceString("IO.FileNotFound_FileName"), + fileNameOrCodeBase), + fileNameOrCodeBase); // Save this exception so we can throw it if we also don't find the .EXE + retAssembly = null; + } + + if (retAssembly == null) + { + // LoadFile will always throw, but LoadFrom will only throw if throwOnFileNotFound is true. + // If an exception was thrown, we must have a dllNotFoundException ready for throwing later. + BCLDebug.Assert((useLoadFile == false && throwOnFileNotFound == false) || dllNotFoundException != null, + "(useLoadFile == false && throwOnFileNotFound == false) || dllNotFoundException != null"); + + assemblyFile.Remove(assemblyFile.Length - 4, 4); + assemblyFile.Append(".EXE"); + fileNameOrCodeBase = assemblyFile.ToString(); + + if (useLoadFile == false) + loadFromAsmName.CodeBase = fileNameOrCodeBase; + + try + { + retAssembly = useLoadFile ? nLoadFile(fileNameOrCodeBase, null) : + nLoad(loadFromAsmName, fileNameOrCodeBase, null, this, ref stackMark, +#if FEATURE_HOSTED_BINDER + IntPtr.Zero, +#endif + false /* do not throw on file not found */, false, false); + + } + catch (FileNotFoundException) + { + retAssembly = null; + } + + // It would be messy to have a FileNotFoundException that reports both .DLL and .EXE not found. + // Using a .DLL extension for satellite assemblies is the more common scenario, + // so just throw that exception. + + // In classic (i.e. non-AppX) mode, if binder logging is turned on, there will be separate logs for + // the .DLL and .EXE load attempts if the user is interested in digging deeper. + + if (retAssembly == null && throwOnFileNotFound) + throw dllNotFoundException; + } + } + catch (DirectoryNotFoundException) + { + if (throwOnFileNotFound) + throw; + retAssembly = null; + } + // No other exceptions should be caught here. + + return retAssembly; + } + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + static internal extern RuntimeAssembly nLoadFile(String path, Evidence evidence); + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + static internal extern RuntimeAssembly nLoadImage(byte[] rawAssembly, + byte[] rawSymbolStore, + Evidence evidence, + ref StackCrawlMark stackMark, + bool fIntrospection, + SecurityContextSource securityContextSource); +#if FEATURE_CORECLR + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + static internal extern unsafe void nLoadFromUnmanagedArray(bool fIntrospection, + byte* assemblyContent, + ulong assemblySize, + byte* pdbContent, + ulong pdbSize, + StackCrawlMarkHandle stackMark, + ObjectHandleOnStack retAssembly); +#endif + + [System.Security.SecurityCritical] // auto-generated + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + [SuppressUnmanagedCodeSecurity] + private extern static void GetModules(RuntimeAssembly assembly, + bool loadIfNotFound, + bool getResourceModules, + ObjectHandleOnStack retModuleHandles); + + [System.Security.SecuritySafeCritical] // auto-generated + private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, + bool getResourceModules) + { + RuntimeModule[] modules = null; + GetModules(GetNativeHandle(), loadIfNotFound, getResourceModules, JitHelpers.GetObjectHandleOnStack(ref modules)); + return modules; + } + + public override Module[] GetModules(bool getResourceModules) + { + return GetModulesInternal(true, getResourceModules); + } + + public override Module[] GetLoadedModules(bool getResourceModules) + { + return GetModulesInternal(false, getResourceModules); + } + + [System.Security.SecuritySafeCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + internal static extern RuntimeModule GetManifestModule(RuntimeAssembly assembly); + +#if FEATURE_APTCA + [System.Security.SecuritySafeCritical] + [MethodImplAttribute(MethodImplOptions.InternalCall)] + internal static extern bool AptcaCheck(RuntimeAssembly targetAssembly, RuntimeAssembly sourceAssembly); +#endif // FEATURE_APTCA + + [System.Security.SecurityCritical] // auto-generated + [MethodImplAttribute(MethodImplOptions.InternalCall)] + internal static extern int GetToken(RuntimeAssembly assembly); + } +} |