Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Reflection / Assembly.cs / 1305376 / Assembly.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*==============================================================================
**
** Class: Assembly
**
** [....]
** [....]
**
**
** 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 System.Reflection.Cache;
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)]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Unrestricted = true)]
public abstract class Assembly : _Assembly, IEvidenceFactory, ICustomAttributeProvider, ISerializable
{
#region constructors
protected Assembly() {}
#endregion
#region public static methods
[ResourceExposure(ResourceScope.None)]
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);
}
public override bool Equals(object o)
{
return base.Equals(o);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
#endif // !FEATURE_CORECLR
// Locate an assembly by the name of the file containing the manifest.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly LoadFrom(String assemblyFile)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadFrom(
assemblyFile,
null, // securityEvidence
null, // hashValue
AssemblyHashAlgorithm.None,
false,// forIntrospection
false,// suppressSecurityChecks
ref stackMark);
}
// Locate an assembly for reflection by the name of the file containing the manifest.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly ReflectionOnlyLoadFrom(String assemblyFile)
{
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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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)
{
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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadFrom(
assemblyFile,
securityEvidence,
hashValue,
hashAlgorithm,
false,
false,
ref stackMark);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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]
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly UnsafeLoadFrom(string assemblyFile)
{
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)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, false /*forIntrospection*/);
}
// 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)
{
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)
{
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.
[System.Security.SecuritySafeCritical] // auto-generated
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(AssemblyName assemblyRef)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, ref stackMark, 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)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, assemblySecurity, ref stackMark, 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.
[System.Security.SecuritySafeCritical] // auto-generated
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(byte[] rawAssembly)
{
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)
{
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.
[System.Security.SecuritySafeCritical] // auto-generated
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(byte[] rawAssembly,
byte[] rawSymbolStore)
{
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)
{
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);
}
[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)
{
#if FEATURE_CAS_POLICY
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();
if (zone == null || zone.SecurityZone != SecurityZone.MyComputer)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
}
}
#endif // FEATURE_CAS_POLICY
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.nLoadImage(
rawAssembly,
rawSymbolStore,
securityEvidence,
ref stackMark,
false, // fIntrospection
SecurityContextSource.CurrentAssembly);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static Assembly LoadFile(String path)
{
new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path).Demand();
return RuntimeAssembly.nLoadFile(path, null);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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)
{
#if FEATURE_CAS_POLICY
if (securityEvidence != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
}
#endif // FEATURE_CAS_POLICY
new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path).Demand();
return RuntimeAssembly.nLoadFile(path, securityEvidence);
}
#if FEATURE_CORECLR
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(Stream assemblyStream, Stream pdbStream)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadFromStream(assemblyStream, pdbStream, ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(Stream assemblyStream)
{
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);
}
#if !FEATURE_CORECLR
[System.Security.SecuritySafeCritical] // auto-generated
public static Assembly GetEntryAssembly() {
AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
if (domainManager == null)
domainManager = new AppDomainManager();
return domainManager.EntryAssembly;
}
#endif // !FEATURE_CORECLR
#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
{
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get
{
throw new NotImplementedException();
}
}
public virtual String EscapedCodeBase
{
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get
{
return AssemblyName.EscapeCodeBase(CodeBase);
}
}
public virtual AssemblyName GetName()
{
return GetName(false);
}
public virtual AssemblyName GetName(bool copiedName)
{
throw new NotImplementedException();
}
#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
public virtual String FullName
{
get
{
throw new NotImplementedException();
}
}
public virtual MethodInfo EntryPoint
{
get
{
throw new NotImplementedException();
}
}
Type _Assembly.GetType()
{
return base.GetType();
}
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 Type[] GetExportedTypes()
{
throw new NotImplementedException();
}
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly, ResourceScope.Machine | ResourceScope.Assembly)]
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 Object[] GetCustomAttributes(bool inherit)
{
Contract.Ensures(Contract.Result() != null);
throw new NotImplementedException();
}
public virtual Object[] GetCustomAttributes(Type attributeType, bool inherit)
{
Contract.Ensures(Contract.Result() != null);
throw new NotImplementedException();
}
public virtual bool IsDefined(Type attributeType, bool inherit)
{
throw new NotImplementedException();
}
public virtual IList 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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public Module LoadModule(String moduleName,
byte[] rawModule)
{
return LoadModule(moduleName, rawModule, null);
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public Module[] GetLoadedModules()
{
return GetLoadedModules(false);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public virtual Module[] GetLoadedModules(bool getResourceModules)
{
throw new NotImplementedException();
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public Module[] GetModules()
{
return GetModules(false);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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.)
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public virtual FileStream GetFile(String name)
{
throw new NotImplementedException();
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public virtual FileStream[] GetFiles()
{
return GetFiles(false);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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();
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
{
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
}
#if !FEATURE_CORECLR
[System.Runtime.ForceTokenStabilization]
#endif //!FEATURE_CORECLR
[Serializable]
#if FEATURE_COMINTEROP
internal class RuntimeAssembly : Assembly, ICustomQueryInterface
{
#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
#if false // hack for createBclSmall
}
#endif // hack for createBclSmall
#else
internal class RuntimeAssembly : Assembly
{
#endif // FEATURE_COMINTEROP
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 InternalCache m_cachedData;
private object m_syncRoot; // Used to keep collectible types alive and as the syncroot for reflection.emit
#if !FEATURE_CORECLR
[System.Runtime.ForceTokenStabilization]
#endif //!FEATURE_CORECLR
private IntPtr m_assembly; // slack for ptr datum on unmanaged side
#endregion
internal object SyncRoot
{
get
{
if (m_syncRoot == null)
{
Interlocked.CompareExchange(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
[ResourceExposure(ResourceScope.Machine)]
[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
{
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
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;
}
[System.Security.SecurityCritical] // auto-generated
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
[ResourceExposure(ResourceScope.None)]
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.
String s;
if ((s = (String)Cache[CacheObjType.AssemblyName]) != null)
return s;
GetFullName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref s));
if (s != null)
Cache[CacheObjType.AssemblyName] = s;
return s;
}
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
internal extern static void GetForwardedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes);
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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;
}
// 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
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private extern static void GetEvidence(RuntimeAssembly assembly, ObjectHandleOnStack retEvidence);
[SecurityCritical]
[ResourceExposure(ResourceScope.None)]
[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 GetCustomAttributesData()
{
return CustomAttributeData.GetCustomAttributesInternal(this);
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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, ref stackMark, forIntrospection, suppressSecurityChecks);
}
[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,
bool forIntrospection)
{
if (assemblyString == null)
throw new ArgumentNullException("assemblyString");
Contract.EndContractBlock();
if ((assemblyString.Length == 0) ||
(assemblyString[0] == '\0'))
throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength"));
AssemblyName an = new AssemblyName();
RuntimeAssembly assembly = null;
an.Name = assemblyString;
int hr = an.nInit(out assembly, forIntrospection, true);
if (hr == System.__HResults.FUSION_E_INVALID_NAME) {
return assembly;
}
return InternalLoadAssemblyName(an, assemblySecurity, ref stackMark, forIntrospection, false);
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
internal static RuntimeAssembly InternalLoadAssemblyName(
AssemblyName assemblyRef,
Evidence assemblySecurity,
ref StackCrawlMark stackMark,
bool forIntrospection,
bool suppressSecurityChecks)
{
if (assemblyRef == null)
throw new ArgumentNullException("assemblyRef");
Contract.EndContractBlock();
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)
{
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
}
}
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, null, ref stackMark, true, forIntrospection, suppressSecurityChecks);
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern RuntimeAssembly _nLoad(AssemblyName fileName,
String codeBase,
Evidence assemblySecurity,
RuntimeAssembly locationHint,
ref StackCrawlMark stackMark,
bool throwOnFileNotFound,
bool forIntrospection,
bool suppressSecurityChecks);
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
private static RuntimeAssembly nLoad(AssemblyName fileName,
String codeBase,
Evidence assemblySecurity,
RuntimeAssembly locationHint,
ref StackCrawlMark stackMark,
bool throwOnFileNotFound,
bool forIntrospection,
bool suppressSecurityChecks)
{
return _nLoad(fileName, codeBase, assemblySecurity, locationHint, ref stackMark, 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;
RuntimeAssembly result = null;
AssemblyName an = new AssemblyName(partialName);
if (!IsSimplyNamed(an))
{
if (cropPublicKey)
{
an.SetPublicKey(null);
an.SetPublicKeyToken(null);
}
AssemblyName GACAssembly = EnumerateCache(an);
if(GACAssembly != null)
result = InternalLoadAssemblyName(GACAssembly, null,
ref stackMark, false, false);
}
return result;
}
[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();
}
RuntimeAssembly result = null;
try {
result = nLoad(an, null, securityEvidence, null, ref stackMark, true, false, false);
}
catch(Exception e) {
if (e.IsTransient)
throw e;
if (IsUserError(e))
throw;
if (IsSimplyNamed(an))
return null;
AssemblyName GACAssembly = EnumerateCache(an);
if(GACAssembly != null)
return InternalLoadAssemblyName(GACAssembly, securityEvidence, ref stackMark, false, false);
}
return result;
}
[SecuritySafeCritical]
private static bool IsUserError(Exception e)
{
return (uint)Marshal.GetHRForException(e) == 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
[ResourceExposure(ResourceScope.None)]
[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())
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();
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
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[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);
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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.)
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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);
return fs;
}
// Returns the names of all the resources
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private extern static void GetExecutingAssembly(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly);
[System.Security.SecurityCritical] // auto-generated
internal static Assembly 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)]
[ResourceExposure(ResourceScope.None)]
private static extern AssemblyName[] GetReferencedAssemblies(RuntimeAssembly assembly);
[System.Security.SecuritySafeCritical] // auto-generated
public override AssemblyName[] GetReferencedAssemblies()
{
return GetReferencedAssemblies(GetNativeHandle());
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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
[ResourceExposure(ResourceScope.Machine)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private static extern void GetLocation(RuntimeAssembly assembly, StringHandleOnStack retString);
public override String Location
{
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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());
}
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
///
/// Determine if this assembly was loaded from a location under the AppBase for security
/// purposes. For instance, strong name bypass is disabled for assemblies considered outside
/// the AppBase.
///
/// This method is called from the VM: AssemblySecurityDescriptor::WasAssemblyLoadedFromAppBase
///
[System.Security.SecurityCritical] // auto-generated
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
private bool IsAssemblyUnderAppBase() {
string assemblyLocation = Location;
// Assemblies that are loaded without a location will be considered part of the app
if (String.IsNullOrEmpty(assemblyLocation)) {
return true;
}
// Compare the paths using the FileIOAccess mechanism that FileIOPermission uses internally. If
// assemblyAccess is a subset of appbaseAccess (in FileIOPermission terms, appBaseAccess is the
// demand set, and assemblyAccess is the grant set) that means assembly must be under the AppBase.
FileIOAccess assemblyAccess = new FileIOAccess(Path.GetFullPathInternal(assemblyLocation));
FileIOAccess appBaseAccess = new FileIOAccess(Path.GetFullPathInternal(AppDomain.CurrentDomain.BaseDirectory));
return assemblyAccess.IsSubsetOf(appBaseAccess);
}
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]
[ResourceExposure(ResourceScope.None)]
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"));
// For cases where we're loading an embedded resource from an assembly,
// in V1 we do not have any serious lifetime issues with the
// UnmanagedMemoryStream. If the Stream is only used
// in the AppDomain that contains the assembly, then if that AppDomain
// is unloaded, we will collect all of the objects in the AppDomain first
// before unloading assemblies. If the Stream is shared across AppDomains,
// then the original AppDomain was unloaded, accesses to this Stream will
// throw an exception saying the appdomain was unloaded. This is
// guaranteed be EE AppDomain goo. And for shared assemblies like
// mscorlib, their lifetime is the lifetime of the process, so the
// assembly will NOT be unloaded, so the resource will always be in memory.
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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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 ((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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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)]
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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]
[ResourceExposure(ResourceScope.None)]
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;
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
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
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);
}
[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 a = nLoad(an, null, null, this, ref stackMark, throwOnFileNotFound, false, false);
if (a == this) {
throw new FileNotFoundException(String.Format(culture, Environment.GetResourceString("IO.FileNotFound_FileName"), an.Name));
}
return a;
}
internal InternalCache Cache {
get {
// This grabs an internal copy of m_cachedData and uses
// that instead of looking at m_cachedData directly because
// the cache may get cleared asynchronously. This prevents
// us from having to take a lock.
InternalCache cache = m_cachedData;
if (cache == null) {
cache = new InternalCache("Assembly");
m_cachedData = cache;
// If assembly is not collectible assembly, then arrange to clear the
// cache at the next finalization.
if (SyncRoot.GetType() != typeof(LoaderAllocator))
GC.ClearCache += new ClearCacheHandler(OnCacheClear);
}
return cache;
}
}
internal void OnCacheClear(Object sender, ClearCacheEventArgs cacheEventArgs)
{
m_cachedData = null;
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
static internal extern RuntimeAssembly nLoadFile(String path, Evidence evidence);
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
internal Module[] GetModulesInternal(bool loadIfNotFound,
bool getResourceModules)
{
Module[] modules = null;
GetModules(GetNativeHandle(), loadIfNotFound, getResourceModules, JitHelpers.GetObjectHandleOnStack(ref modules));
return modules;
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public override Module[] GetModules(bool getResourceModules)
{
return GetModulesInternal(true, getResourceModules);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public override Module[] GetLoadedModules(bool getResourceModules)
{
return GetModulesInternal(false, getResourceModules);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern RuntimeModule GetManifestModule(RuntimeAssembly assembly);
#if FEATURE_APTCA
[System.Security.SecuritySafeCritical]
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool AptcaCheck(RuntimeAssembly targetAssembly, RuntimeAssembly sourceAssembly);
#endif // FEATURE_APTCA
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern int GetToken(RuntimeAssembly assembly);
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*==============================================================================
**
** Class: Assembly
**
** [....]
** [....]
**
**
** 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 System.Reflection.Cache;
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)]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Unrestricted = true)]
public abstract class Assembly : _Assembly, IEvidenceFactory, ICustomAttributeProvider, ISerializable
{
#region constructors
protected Assembly() {}
#endregion
#region public static methods
[ResourceExposure(ResourceScope.None)]
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);
}
public override bool Equals(object o)
{
return base.Equals(o);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
#endif // !FEATURE_CORECLR
// Locate an assembly by the name of the file containing the manifest.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly LoadFrom(String assemblyFile)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadFrom(
assemblyFile,
null, // securityEvidence
null, // hashValue
AssemblyHashAlgorithm.None,
false,// forIntrospection
false,// suppressSecurityChecks
ref stackMark);
}
// Locate an assembly for reflection by the name of the file containing the manifest.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly ReflectionOnlyLoadFrom(String assemblyFile)
{
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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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)
{
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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadFrom(
assemblyFile,
securityEvidence,
hashValue,
hashAlgorithm,
false,
false,
ref stackMark);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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]
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly UnsafeLoadFrom(string assemblyFile)
{
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)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, false /*forIntrospection*/);
}
// 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)
{
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)
{
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.
[System.Security.SecuritySafeCritical] // auto-generated
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(AssemblyName assemblyRef)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, ref stackMark, 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)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, assemblySecurity, ref stackMark, 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.
[System.Security.SecuritySafeCritical] // auto-generated
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(byte[] rawAssembly)
{
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)
{
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.
[System.Security.SecuritySafeCritical] // auto-generated
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(byte[] rawAssembly,
byte[] rawSymbolStore)
{
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)
{
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);
}
[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)
{
#if FEATURE_CAS_POLICY
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();
if (zone == null || zone.SecurityZone != SecurityZone.MyComputer)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
}
}
#endif // FEATURE_CAS_POLICY
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.nLoadImage(
rawAssembly,
rawSymbolStore,
securityEvidence,
ref stackMark,
false, // fIntrospection
SecurityContextSource.CurrentAssembly);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static Assembly LoadFile(String path)
{
new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path).Demand();
return RuntimeAssembly.nLoadFile(path, null);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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)
{
#if FEATURE_CAS_POLICY
if (securityEvidence != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
}
#endif // FEATURE_CAS_POLICY
new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path).Demand();
return RuntimeAssembly.nLoadFile(path, securityEvidence);
}
#if FEATURE_CORECLR
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(Stream assemblyStream, Stream pdbStream)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoadFromStream(assemblyStream, pdbStream, ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Assembly Load(Stream assemblyStream)
{
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);
}
#if !FEATURE_CORECLR
[System.Security.SecuritySafeCritical] // auto-generated
public static Assembly GetEntryAssembly() {
AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
if (domainManager == null)
domainManager = new AppDomainManager();
return domainManager.EntryAssembly;
}
#endif // !FEATURE_CORECLR
#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
{
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get
{
throw new NotImplementedException();
}
}
public virtual String EscapedCodeBase
{
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get
{
return AssemblyName.EscapeCodeBase(CodeBase);
}
}
public virtual AssemblyName GetName()
{
return GetName(false);
}
public virtual AssemblyName GetName(bool copiedName)
{
throw new NotImplementedException();
}
#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
public virtual String FullName
{
get
{
throw new NotImplementedException();
}
}
public virtual MethodInfo EntryPoint
{
get
{
throw new NotImplementedException();
}
}
Type _Assembly.GetType()
{
return base.GetType();
}
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 Type[] GetExportedTypes()
{
throw new NotImplementedException();
}
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly, ResourceScope.Machine | ResourceScope.Assembly)]
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 Object[] GetCustomAttributes(bool inherit)
{
Contract.Ensures(Contract.Result() != null);
throw new NotImplementedException();
}
public virtual Object[] GetCustomAttributes(Type attributeType, bool inherit)
{
Contract.Ensures(Contract.Result() != null);
throw new NotImplementedException();
}
public virtual bool IsDefined(Type attributeType, bool inherit)
{
throw new NotImplementedException();
}
public virtual IList 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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public Module LoadModule(String moduleName,
byte[] rawModule)
{
return LoadModule(moduleName, rawModule, null);
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public Module[] GetLoadedModules()
{
return GetLoadedModules(false);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public virtual Module[] GetLoadedModules(bool getResourceModules)
{
throw new NotImplementedException();
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public Module[] GetModules()
{
return GetModules(false);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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.)
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public virtual FileStream GetFile(String name)
{
throw new NotImplementedException();
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public virtual FileStream[] GetFiles()
{
return GetFiles(false);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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();
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
{
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
}
#if !FEATURE_CORECLR
[System.Runtime.ForceTokenStabilization]
#endif //!FEATURE_CORECLR
[Serializable]
#if FEATURE_COMINTEROP
internal class RuntimeAssembly : Assembly, ICustomQueryInterface
{
#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
#if false // hack for createBclSmall
}
#endif // hack for createBclSmall
#else
internal class RuntimeAssembly : Assembly
{
#endif // FEATURE_COMINTEROP
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 InternalCache m_cachedData;
private object m_syncRoot; // Used to keep collectible types alive and as the syncroot for reflection.emit
#if !FEATURE_CORECLR
[System.Runtime.ForceTokenStabilization]
#endif //!FEATURE_CORECLR
private IntPtr m_assembly; // slack for ptr datum on unmanaged side
#endregion
internal object SyncRoot
{
get
{
if (m_syncRoot == null)
{
Interlocked.CompareExchange(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
[ResourceExposure(ResourceScope.Machine)]
[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
{
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
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;
}
[System.Security.SecurityCritical] // auto-generated
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
[ResourceExposure(ResourceScope.None)]
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.
String s;
if ((s = (String)Cache[CacheObjType.AssemblyName]) != null)
return s;
GetFullName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref s));
if (s != null)
Cache[CacheObjType.AssemblyName] = s;
return s;
}
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
internal extern static void GetForwardedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes);
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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;
}
// 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
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private extern static void GetEvidence(RuntimeAssembly assembly, ObjectHandleOnStack retEvidence);
[SecurityCritical]
[ResourceExposure(ResourceScope.None)]
[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 GetCustomAttributesData()
{
return CustomAttributeData.GetCustomAttributesInternal(this);
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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, ref stackMark, forIntrospection, suppressSecurityChecks);
}
[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,
bool forIntrospection)
{
if (assemblyString == null)
throw new ArgumentNullException("assemblyString");
Contract.EndContractBlock();
if ((assemblyString.Length == 0) ||
(assemblyString[0] == '\0'))
throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength"));
AssemblyName an = new AssemblyName();
RuntimeAssembly assembly = null;
an.Name = assemblyString;
int hr = an.nInit(out assembly, forIntrospection, true);
if (hr == System.__HResults.FUSION_E_INVALID_NAME) {
return assembly;
}
return InternalLoadAssemblyName(an, assemblySecurity, ref stackMark, forIntrospection, false);
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
internal static RuntimeAssembly InternalLoadAssemblyName(
AssemblyName assemblyRef,
Evidence assemblySecurity,
ref StackCrawlMark stackMark,
bool forIntrospection,
bool suppressSecurityChecks)
{
if (assemblyRef == null)
throw new ArgumentNullException("assemblyRef");
Contract.EndContractBlock();
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)
{
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
}
}
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, null, ref stackMark, true, forIntrospection, suppressSecurityChecks);
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern RuntimeAssembly _nLoad(AssemblyName fileName,
String codeBase,
Evidence assemblySecurity,
RuntimeAssembly locationHint,
ref StackCrawlMark stackMark,
bool throwOnFileNotFound,
bool forIntrospection,
bool suppressSecurityChecks);
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
private static RuntimeAssembly nLoad(AssemblyName fileName,
String codeBase,
Evidence assemblySecurity,
RuntimeAssembly locationHint,
ref StackCrawlMark stackMark,
bool throwOnFileNotFound,
bool forIntrospection,
bool suppressSecurityChecks)
{
return _nLoad(fileName, codeBase, assemblySecurity, locationHint, ref stackMark, 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;
RuntimeAssembly result = null;
AssemblyName an = new AssemblyName(partialName);
if (!IsSimplyNamed(an))
{
if (cropPublicKey)
{
an.SetPublicKey(null);
an.SetPublicKeyToken(null);
}
AssemblyName GACAssembly = EnumerateCache(an);
if(GACAssembly != null)
result = InternalLoadAssemblyName(GACAssembly, null,
ref stackMark, false, false);
}
return result;
}
[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();
}
RuntimeAssembly result = null;
try {
result = nLoad(an, null, securityEvidence, null, ref stackMark, true, false, false);
}
catch(Exception e) {
if (e.IsTransient)
throw e;
if (IsUserError(e))
throw;
if (IsSimplyNamed(an))
return null;
AssemblyName GACAssembly = EnumerateCache(an);
if(GACAssembly != null)
return InternalLoadAssemblyName(GACAssembly, securityEvidence, ref stackMark, false, false);
}
return result;
}
[SecuritySafeCritical]
private static bool IsUserError(Exception e)
{
return (uint)Marshal.GetHRForException(e) == 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
[ResourceExposure(ResourceScope.None)]
[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())
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();
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
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[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);
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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.)
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
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);
return fs;
}
// Returns the names of all the resources
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private extern static void GetExecutingAssembly(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly);
[System.Security.SecurityCritical] // auto-generated
internal static Assembly 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)]
[ResourceExposure(ResourceScope.None)]
private static extern AssemblyName[] GetReferencedAssemblies(RuntimeAssembly assembly);
[System.Security.SecuritySafeCritical] // auto-generated
public override AssemblyName[] GetReferencedAssemblies()
{
return GetReferencedAssemblies(GetNativeHandle());
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[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
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
[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
[ResourceExposure(ResourceScope.Machine)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private static extern void GetLocation(RuntimeAssembly assembly, StringHandleOnStack retString);
public override String Location
{
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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());
}
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
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
///
/// Determine if this assembly was loaded from a location under the AppBase for security
/// purposes. For instance, strong name bypass is disabled for assemblies considered outside
/// the AppBase.
///
/// This method is called from the VM: AssemblySecurityDescriptor::WasAssemblyLoadedFromAppBase
///
[System.Security.SecurityCritical] // auto-generated
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
private bool IsAssemblyUnderAppBase() {
string assemblyLocation = Location;
// Assemblies that are loaded without a location will be considered part of the app
if (String.IsNullOrEmpty(assemblyLocation)) {
return true;
}
// Compare the paths using the FileIOAccess mechanism that FileIOPermission uses internally. If
// assemblyAccess is a subset of appbaseAccess (in FileIOPermission terms, appBaseAccess is the
// demand set, and assemblyAccess is the grant set) that means assembly must be under the AppBase.
FileIOAccess assemblyAccess = new FileIOAccess(Path.GetFullPathInternal(assemblyLocation));
FileIOAccess appBaseAccess = new FileIOAccess(Path.GetFullPathInternal(AppDomain.CurrentDomain.BaseDirectory));
return assemblyAccess.IsSubsetOf(appBaseAccess);
}
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]
[ResourceExposure(ResourceScope.None)]
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"));
// For cases where we're loading an embedded resource from an assembly,
// in V1 we do not have any serious lifetime issues with the
// UnmanagedMemoryStream. If the Stream is only used
// in the AppDomain that contains the assembly, then if that AppDomain
// is unloaded, we will collect all of the objects in the AppDomain first
// before unloading assemblies. If the Stream is shared across AppDomains,
// then the original AppDomain was unloaded, accesses to this Stream will
// throw an exception saying the appdomain was unloaded. This is
// guaranteed be EE AppDomain goo. And for shared assemblies like
// mscorlib, their lifetime is the lifetime of the process, so the
// assembly will NOT be unloaded, so the resource will always be in memory.
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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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 ((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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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)]
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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]
[ResourceExposure(ResourceScope.None)]
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;
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
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
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);
}
[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 a = nLoad(an, null, null, this, ref stackMark, throwOnFileNotFound, false, false);
if (a == this) {
throw new FileNotFoundException(String.Format(culture, Environment.GetResourceString("IO.FileNotFound_FileName"), an.Name));
}
return a;
}
internal InternalCache Cache {
get {
// This grabs an internal copy of m_cachedData and uses
// that instead of looking at m_cachedData directly because
// the cache may get cleared asynchronously. This prevents
// us from having to take a lock.
InternalCache cache = m_cachedData;
if (cache == null) {
cache = new InternalCache("Assembly");
m_cachedData = cache;
// If assembly is not collectible assembly, then arrange to clear the
// cache at the next finalization.
if (SyncRoot.GetType() != typeof(LoaderAllocator))
GC.ClearCache += new ClearCacheHandler(OnCacheClear);
}
return cache;
}
}
internal void OnCacheClear(Object sender, ClearCacheEventArgs cacheEventArgs)
{
m_cachedData = null;
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
static internal extern RuntimeAssembly nLoadFile(String path, Evidence evidence);
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[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
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
internal Module[] GetModulesInternal(bool loadIfNotFound,
bool getResourceModules)
{
Module[] modules = null;
GetModules(GetNativeHandle(), loadIfNotFound, getResourceModules, JitHelpers.GetObjectHandleOnStack(ref modules));
return modules;
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public override Module[] GetModules(bool getResourceModules)
{
return GetModulesInternal(true, getResourceModules);
}
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)]
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)]
public override Module[] GetLoadedModules(bool getResourceModules)
{
return GetModulesInternal(false, getResourceModules);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern RuntimeModule GetManifestModule(RuntimeAssembly assembly);
#if FEATURE_APTCA
[System.Security.SecuritySafeCritical]
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool AptcaCheck(RuntimeAssembly targetAssembly, RuntimeAssembly sourceAssembly);
#endif // FEATURE_APTCA
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern int GetToken(RuntimeAssembly assembly);
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.