internal static RuntimeType GetCallerType(ref StackCrawlMark stackMark)
{
RuntimeType result = null;
RuntimeMethodHandle.GetCallerType(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack <RuntimeType>(ref result));
return(result);
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly retAssembly = null;
GetExecutingAssembly(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
return(retAssembly);
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly?retAssembly = null;
GetExecutingAssemblyNative(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
return(retAssembly !); // TODO-NULLABLE: Confirm this can never be null
}
internal static Assembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly o = null;
GetExecutingAssembly(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack <RuntimeAssembly>(ref o));
return(o);
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly?retAssembly = null;
GetExecutingAssemblyNative(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
return(retAssembly !); // TODO-NULLABLE: Remove ! when nullable attributes are respected
}
internal static RuntimeType GetCallerType(ref StackCrawlMark stackMark)
{
RuntimeType o = null;
GetCallerType(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack <RuntimeType>(ref o));
return(o);
}
internal unsafe Stream GetManifestResourceStream(string name, ref StackCrawlMark stackMark, bool skipSecurityCheck)
{
ulong length = 0L;
byte *pointer = GetResource(this.GetNativeHandle(), name, out length, JitHelpers.GetStackCrawlMarkHandle(ref stackMark), skipSecurityCheck);
if (pointer == null)
{
return(null);
}
if (length > 0x7fffffffffffffffL)
{
throw new NotImplementedException(Environment.GetResourceString("NotImplemented_ResourcesLongerThan2^63"));
}
return(new UnmanagedMemoryStream(pointer, (long)length, (long)length, FileAccess.Read, true));
}
public static bool IsGranted(IPermission perm)
{
if (perm == null)
{
return(true);
}
PermissionSet granted = null, denied = null;
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
GetGrantedPermissions(JitHelpers.GetObjectHandleOnStack(ref granted),
JitHelpers.GetObjectHandleOnStack(ref denied),
JitHelpers.GetStackCrawlMarkHandle(ref stackMark));
return(granted.Contains(perm) && (denied == null || !denied.Contains(perm)));
}
internal static RuntimeType GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark, bool loadTypeFromPartialName)
{
if ((name == null) || (name.Length == 0))
{
if (throwOnError)
{
throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
}
return(null);
}
RuntimeType o = null;
GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly, JitHelpers.GetStackCrawlMarkHandle(ref stackMark), loadTypeFromPartialName, JitHelpers.GetObjectHandleOnStack <RuntimeType>(ref o));
return(o);
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
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));
}
private static Module DefineDynamicModule(RuntimeAssembly containingAssembly,
bool emitSymbolInfo,
String name,
String filename,
ref StackCrawlMark stackMark,
ref IntPtr pInternalSymWriter,
bool fIsTransient,
out int tkFile)
{
RuntimeModule retModule = null;
DefineDynamicModule(containingAssembly.GetNativeHandle(),
emitSymbolInfo,
name,
filename,
JitHelpers.GetStackCrawlMarkHandle(ref stackMark),
ref pInternalSymWriter,
JitHelpers.GetObjectHandleOnStack(ref retModule),
fIsTransient,
out tkFile);
return(retModule);
}
public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
{
RuntimeAssembly o = null;
string s = null;
StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
int num = GetManifestResourceInfo(this.GetNativeHandle(), resourceName, JitHelpers.GetObjectHandleOnStack <RuntimeAssembly>(ref o), JitHelpers.GetStringHandleOnStack(ref s), JitHelpers.GetStackCrawlMarkHandle(ref lookForMyCaller));
if (num == -1)
{
return(null);
}
return(new ManifestResourceInfo(o, s, (ResourceLocation)num));
}
public static void SwapMethodBody(Type cls, int methodtoken, IntPtr rgIL, int methodSize, int flags)
{
InternalModuleBuilder internalModule;
RuntimeType runtimeType;
if ((methodSize <= 0) || (methodSize >= 0x3f0000))
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadSizeForData"), "methodSize");
}
if (cls == null)
{
throw new ArgumentNullException("cls");
}
Module module = cls.Module;
ModuleBuilder builder2 = module as ModuleBuilder;
if (builder2 != null)
{
internalModule = builder2.InternalModule;
}
else
{
internalModule = module as InternalModuleBuilder;
}
if (internalModule == null)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NotDynamicModule"));
}
if (cls is TypeBuilder)
{
TypeBuilder builder3 = (TypeBuilder)cls;
if (!builder3.m_hasBeenCreated)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NotAllTypesAreBaked", new object[] { builder3.Name }));
}
runtimeType = builder3.m_runtimeType;
}
else
{
runtimeType = cls as RuntimeType;
}
if (runtimeType == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "cls");
}
StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
RuntimeAssembly runtimeAssembly = internalModule.GetRuntimeAssembly();
lock (runtimeAssembly.SyncRoot)
{
SwapMethodBody(runtimeType.GetTypeHandleInternal(), methodtoken, rgIL, methodSize, flags, JitHelpers.GetStackCrawlMarkHandle(ref lookForMyCaller));
}
}
internal static RuntimeType GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark, IntPtr pPrivHostBinder, bool loadTypeFromPartialName)
{
if (name != null && name.Length != 0)
{
RuntimeType result = null;
RuntimeTypeHandle.GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly, JitHelpers.GetStackCrawlMarkHandle(ref stackMark), pPrivHostBinder, loadTypeFromPartialName, JitHelpers.GetObjectHandleOnStack <RuntimeType>(ref result));
return(result);
}
if (throwOnError)
{
throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
}
return(null);
}
public static void SwapMethodBody(Type cls, int methodtoken, IntPtr rgIL, int methodSize, int flags)
{
if (methodSize <= 0 || methodSize >= 4128768)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadSizeForData"), "methodSize");
}
if (cls == null)
{
throw new ArgumentNullException("cls");
}
Module module = cls.Module;
ModuleBuilder moduleBuilder = module as ModuleBuilder;
InternalModuleBuilder internalModuleBuilder;
if (moduleBuilder != null)
{
internalModuleBuilder = moduleBuilder.InternalModule;
}
else
{
internalModuleBuilder = (module as InternalModuleBuilder);
}
if (internalModuleBuilder == null)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NotDynamicModule"));
}
RuntimeType runtimeType;
if (cls is TypeBuilder)
{
TypeBuilder typeBuilder = (TypeBuilder)cls;
if (!typeBuilder.IsCreated())
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NotAllTypesAreBaked", new object[]
{
typeBuilder.Name
}));
}
runtimeType = typeBuilder.BakedRuntimeType;
}
else
{
runtimeType = (cls as RuntimeType);
}
if (runtimeType == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "cls");
}
StackCrawlMark stackCrawlMark = StackCrawlMark.LookForMyCaller;
RuntimeAssembly runtimeAssembly = internalModuleBuilder.GetRuntimeAssembly();
object syncRoot = runtimeAssembly.SyncRoot;
lock (syncRoot)
{
MethodRental.SwapMethodBody(runtimeType.GetTypeHandleInternal(), methodtoken, rgIL, methodSize, flags, JitHelpers.GetStackCrawlMarkHandle(ref stackCrawlMark));
}
}
public static bool IsGranted(IPermission perm)
{
if (perm != null)
{
PermissionSet o = null;
PermissionSet set2 = null;
StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
GetGrantedPermissions(JitHelpers.GetObjectHandleOnStack <PermissionSet>(ref o), JitHelpers.GetObjectHandleOnStack <PermissionSet>(ref set2), JitHelpers.GetStackCrawlMarkHandle(ref lookForMyCaller));
if (!o.Contains(perm))
{
return(false);
}
if (set2 != null)
{
return(!set2.Contains(perm));
}
}
return(true);
}
public static bool IsGranted(IPermission perm)
{
if (perm == null)
{
return(true);
}
PermissionSet permissionSet = null;
PermissionSet permissionSet2 = null;
StackCrawlMark stackCrawlMark = StackCrawlMark.LookForMyCaller;
SecurityManager.GetGrantedPermissions(JitHelpers.GetObjectHandleOnStack <PermissionSet>(ref permissionSet), JitHelpers.GetObjectHandleOnStack <PermissionSet>(ref permissionSet2), JitHelpers.GetStackCrawlMarkHandle(ref stackCrawlMark));
return(permissionSet.Contains(perm) && (permissionSet2 == null || !permissionSet2.Contains(perm)));
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static void SwapMethodBody(
Type cls, // [in] class containing the method
int methodtoken, // [in] method token
IntPtr rgIL, // [in] pointer to bytes
int methodSize, // [in] the size of the new method body in bytes
int flags) // [in] flags
{
if (methodSize <= 0 || methodSize >= 0x3f0000)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadSizeForData"), "methodSize");
}
if (cls == null)
{
throw new ArgumentNullException("cls");
}
Contract.EndContractBlock();
Module module = cls.Module;
InternalModuleBuilder internalMB;
ModuleBuilder mb = module as ModuleBuilder;
if (mb != null)
{
internalMB = mb.InternalModule;
}
else
{
internalMB = module as InternalModuleBuilder;
}
// can only swap method body on dynamic module
// dynamic internal module type is always exactly InternalModuleBuilder, non-dynamic is always something different
if (internalMB == null)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NotDynamicModule"));
}
RuntimeType rType;
if (cls is TypeBuilder)
{
// If it is a TypeBuilder, make sure that TypeBuilder is already been baked.
TypeBuilder typeBuilder = (TypeBuilder)cls;
if (!typeBuilder.IsCreated())
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NotAllTypesAreBaked", typeBuilder.Name));
}
// get the corresponding runtime type for the TypeBuilder.
rType = typeBuilder.BakedRuntimeType;
}
else
{
rType = cls as RuntimeType;
}
if (rType == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "cls");
}
StackCrawlMark mark = StackCrawlMark.LookForMyCaller;
RuntimeAssembly rtAssembly = internalMB.GetRuntimeAssembly();
lock (rtAssembly.SyncRoot)
{
SwapMethodBody(rType.GetTypeHandleInternal(), methodtoken, rgIL, methodSize, flags, JitHelpers.GetStackCrawlMarkHandle(ref mark));
}
}
public static bool IsGranted(IPermission perm)
{
if (perm == null)
{
return(true);
}
PermissionSet o1 = (PermissionSet)null;
PermissionSet o2 = (PermissionSet)null;
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
SecurityManager.GetGrantedPermissions(JitHelpers.GetObjectHandleOnStack <PermissionSet>(ref o1), JitHelpers.GetObjectHandleOnStack <PermissionSet>(ref o2), JitHelpers.GetStackCrawlMarkHandle(ref stackMark));
if (!o1.Contains(perm))
{
return(false);
}
if (o2 != null)
{
return(!o2.Contains(perm));
}
return(true);
}
