mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
384 lines
17 KiB
C#
384 lines
17 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Runtime;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using System.ServiceModel.Description;
|
|
|
|
delegate object InvokeDelegate(object target, object[] inputs, object[] outputs);
|
|
delegate IAsyncResult InvokeBeginDelegate(object target, object[] inputs, AsyncCallback asyncCallback, object state);
|
|
delegate object InvokeEndDelegate(object target, object[] outputs, IAsyncResult result);
|
|
delegate object CreateInstanceDelegate();
|
|
|
|
sealed class InvokerUtil
|
|
{
|
|
[Fx.Tag.SecurityNote(Critical = "Holds instance of CriticalHelper which keeps state that was produced within an assert.")]
|
|
[SecurityCritical]
|
|
CriticalHelper helper;
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
|
|
Safe = "Doesn't leak anything.")]
|
|
[SecuritySafeCritical]
|
|
public InvokerUtil()
|
|
{
|
|
helper = new CriticalHelper();
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical helper class 'CriticalHelper'.",
|
|
Safe = "Resultant delegate is self-contained and safe for general consumption, nothing else leaks.")]
|
|
[SecuritySafeCritical]
|
|
internal CreateInstanceDelegate GenerateCreateInstanceDelegate(Type type, ConstructorInfo constructor)
|
|
{
|
|
return helper.GenerateCreateInstanceDelegate(type, constructor);
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical helper class 'CriticalHelper'.",
|
|
Safe = "Resultant delegate is self-contained and safe for general consumption, parameter counts are safe, nothing else leaks.")]
|
|
[SecuritySafeCritical]
|
|
internal InvokeDelegate GenerateInvokeDelegate(MethodInfo method, out int inputParameterCount, out int outputParameterCount)
|
|
{
|
|
return helper.GenerateInvokeDelegate(method, out inputParameterCount, out outputParameterCount);
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical helper class 'CriticalHelper'.",
|
|
Safe = "Resultant delegate is self-contained and safe for general consumption, parameter counts are safe, nothing else leaks.")]
|
|
[SecuritySafeCritical]
|
|
internal InvokeBeginDelegate GenerateInvokeBeginDelegate(MethodInfo method, out int inputParameterCount)
|
|
{
|
|
return helper.GenerateInvokeBeginDelegate(method, out inputParameterCount);
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical helper class 'CriticalHelper'.",
|
|
Safe = "Resultant delegate is self-contained and safe for general consumption, parameter counts are safe, nothing else leaks.")]
|
|
[SecuritySafeCritical]
|
|
internal InvokeEndDelegate GenerateInvokeEndDelegate(MethodInfo method, out int outputParameterCount)
|
|
{
|
|
return helper.GenerateInvokeEndDelegate(method, out outputParameterCount);
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Handles all aspects of IL generation including initializing the DynamicMethod, which requires an elevation."
|
|
+ "Since the ILGenerator is created under an elevation, we lock down access to every aspect of the generation.")]
|
|
#pragma warning disable 618 // have not moved to the v4 security model yet
|
|
[SecurityCritical(SecurityCriticalScope.Everything)]
|
|
#pragma warning restore 618
|
|
class CriticalHelper
|
|
{
|
|
static Type TypeOfObject = typeof(object);
|
|
|
|
CodeGenerator ilg;
|
|
|
|
internal CreateInstanceDelegate GenerateCreateInstanceDelegate(Type type, ConstructorInfo constructor)
|
|
{
|
|
bool requiresMemberAccess = !IsTypeVisible(type) || ConstructorRequiresMemberAccess(constructor);
|
|
|
|
this.ilg = new CodeGenerator();
|
|
try
|
|
{
|
|
ilg.BeginMethod("Create" + type.FullName, typeof(CreateInstanceDelegate), requiresMemberAccess);
|
|
}
|
|
catch (SecurityException securityException)
|
|
{
|
|
if (requiresMemberAccess && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
|
|
{
|
|
DiagnosticUtility.TraceHandledException(securityException, TraceEventType.Warning);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new SecurityException(SR.GetString(
|
|
SR.PartialTrustServiceCtorNotVisible,
|
|
type.FullName)));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
if (type.IsValueType)
|
|
{
|
|
LocalBuilder instanceLocal = ilg.DeclareLocal(type, type.Name + "Instance");
|
|
ilg.LoadZeroValueIntoLocal(type, instanceLocal);
|
|
ilg.Load(instanceLocal);
|
|
}
|
|
else
|
|
{
|
|
ilg.New(constructor);
|
|
}
|
|
ilg.ConvertValue(type, ilg.CurrentMethod.ReturnType);
|
|
return (CreateInstanceDelegate)ilg.EndMethod();
|
|
}
|
|
|
|
internal InvokeDelegate GenerateInvokeDelegate(MethodInfo method, out int inputParameterCount, out int outputParameterCount)
|
|
{
|
|
bool requiresMemberAccess = MethodRequiresMemberAccess(method);
|
|
|
|
this.ilg = new CodeGenerator();
|
|
try
|
|
{
|
|
this.ilg.BeginMethod("SyncInvoke" + method.Name, typeof(InvokeDelegate), requiresMemberAccess);
|
|
}
|
|
catch (SecurityException securityException)
|
|
{
|
|
if (requiresMemberAccess && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
|
|
{
|
|
DiagnosticUtility.TraceHandledException(securityException, TraceEventType.Warning);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new SecurityException(SR.GetString(
|
|
SR.PartialTrustServiceMethodNotVisible,
|
|
method.DeclaringType.FullName,
|
|
method.Name)));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
ArgBuilder targetArg = ilg.GetArg(0);
|
|
ArgBuilder inputParametersArg = ilg.GetArg(1);
|
|
ArgBuilder outputParametersArg = ilg.GetArg(2);
|
|
|
|
ParameterInfo[] parameters = method.GetParameters();
|
|
LocalBuilder returnLocal = ilg.DeclareLocal(ilg.CurrentMethod.ReturnType, "returnParam");
|
|
LocalBuilder[] parameterLocals = new LocalBuilder[parameters.Length];
|
|
DeclareParameterLocals(parameters, parameterLocals);
|
|
|
|
LoadInputParametersIntoLocals(parameters, parameterLocals, inputParametersArg, out inputParameterCount);
|
|
LoadTarget(targetArg, method.ReflectedType);
|
|
LoadParameters(parameters, parameterLocals);
|
|
InvokeMethod(method, returnLocal);
|
|
LoadOutputParametersIntoArray(parameters, parameterLocals, outputParametersArg, out outputParameterCount);
|
|
|
|
ilg.Load(returnLocal);
|
|
return (InvokeDelegate)this.ilg.EndMethod();
|
|
}
|
|
|
|
internal InvokeBeginDelegate GenerateInvokeBeginDelegate(MethodInfo method, out int inputParameterCount)
|
|
{
|
|
bool requiresMemberAccess = MethodRequiresMemberAccess(method);
|
|
|
|
this.ilg = new CodeGenerator();
|
|
try
|
|
{
|
|
this.ilg.BeginMethod("AsyncInvokeBegin" + method.Name, typeof(InvokeBeginDelegate), requiresMemberAccess);
|
|
}
|
|
catch (SecurityException securityException)
|
|
{
|
|
if (requiresMemberAccess && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
|
|
{
|
|
DiagnosticUtility.TraceHandledException(securityException, TraceEventType.Warning);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new SecurityException(SR.GetString(
|
|
SR.PartialTrustServiceMethodNotVisible,
|
|
method.DeclaringType.FullName,
|
|
method.Name)));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
ArgBuilder targetArg = ilg.GetArg(0);
|
|
ArgBuilder inputParametersArg = ilg.GetArg(1);
|
|
ArgBuilder callbackArg = ilg.GetArg(2);
|
|
ArgBuilder stateArg = ilg.GetArg(3);
|
|
|
|
ParameterInfo[] parameters = method.GetParameters();
|
|
LocalBuilder returnLocal = ilg.DeclareLocal(ilg.CurrentMethod.ReturnType, "returnParam");
|
|
LocalBuilder[] parameterLocals = new LocalBuilder[parameters.Length - 2];
|
|
DeclareParameterLocals(parameters, parameterLocals);
|
|
|
|
LoadInputParametersIntoLocals(parameters, parameterLocals, inputParametersArg, out inputParameterCount);
|
|
LoadTarget(targetArg, method.ReflectedType);
|
|
LoadParameters(parameters, parameterLocals);
|
|
ilg.Load(callbackArg);
|
|
ilg.Load(stateArg);
|
|
InvokeMethod(method, returnLocal);
|
|
|
|
ilg.Load(returnLocal);
|
|
return (InvokeBeginDelegate)this.ilg.EndMethod();
|
|
}
|
|
|
|
internal InvokeEndDelegate GenerateInvokeEndDelegate(MethodInfo method, out int outputParameterCount)
|
|
{
|
|
bool requiresMemberAccess = MethodRequiresMemberAccess(method);
|
|
|
|
this.ilg = new CodeGenerator();
|
|
try
|
|
{
|
|
this.ilg.BeginMethod("AsyncInvokeEnd" + method.Name, typeof(InvokeEndDelegate), requiresMemberAccess);
|
|
}
|
|
catch (SecurityException securityException)
|
|
{
|
|
if (requiresMemberAccess && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
|
|
{
|
|
DiagnosticUtility.TraceHandledException(securityException, TraceEventType.Warning);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new SecurityException(SR.GetString(
|
|
SR.PartialTrustServiceMethodNotVisible,
|
|
method.DeclaringType.FullName,
|
|
method.Name)));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
ArgBuilder targetArg = ilg.GetArg(0);
|
|
ArgBuilder outputParametersArg = ilg.GetArg(1);
|
|
ArgBuilder resultArg = ilg.GetArg(2);
|
|
|
|
ParameterInfo[] parameters = method.GetParameters();
|
|
LocalBuilder returnLocal = ilg.DeclareLocal(ilg.CurrentMethod.ReturnType, "returnParam");
|
|
LocalBuilder[] parameterLocals = new LocalBuilder[parameters.Length - 1];
|
|
DeclareParameterLocals(parameters, parameterLocals);
|
|
|
|
LoadZeroValueInputParametersIntoLocals(parameters, parameterLocals);
|
|
LoadTarget(targetArg, method.ReflectedType);
|
|
LoadParameters(parameters, parameterLocals);
|
|
ilg.Load(resultArg);
|
|
InvokeMethod(method, returnLocal);
|
|
LoadOutputParametersIntoArray(parameters, parameterLocals, outputParametersArg, out outputParameterCount);
|
|
|
|
ilg.Load(returnLocal);
|
|
return (InvokeEndDelegate)this.ilg.EndMethod();
|
|
}
|
|
|
|
void DeclareParameterLocals(ParameterInfo[] parameters, LocalBuilder[] parameterLocals)
|
|
{
|
|
for (int i = 0; i < parameterLocals.Length; i++)
|
|
{
|
|
parameterLocals[i] = ilg.DeclareLocal(TypeLoader.GetParameterType(parameters[i]), "param" + i.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
|
|
void LoadInputParametersIntoLocals(ParameterInfo[] parameters, LocalBuilder[] parameterLocals, ArgBuilder inputParametersArg, out int inputParameterCount)
|
|
{
|
|
inputParameterCount = 0;
|
|
for (int i = 0; i < parameterLocals.Length; i++)
|
|
{
|
|
if (ServiceReflector.FlowsIn(parameters[i]))
|
|
{
|
|
Type parameterType = parameterLocals[i].LocalType;
|
|
ilg.LoadArrayElement(inputParametersArg, inputParameterCount);
|
|
if (!parameterType.IsValueType)
|
|
{
|
|
ilg.ConvertValue(TypeOfObject, parameterType);
|
|
ilg.Store(parameterLocals[i]);
|
|
}
|
|
else
|
|
{
|
|
ilg.Dup();
|
|
ilg.If();
|
|
ilg.ConvertValue(TypeOfObject, parameterType);
|
|
ilg.Store(parameterLocals[i]);
|
|
ilg.Else();
|
|
ilg.Pop();
|
|
ilg.LoadZeroValueIntoLocal(parameterType, parameterLocals[i]);
|
|
ilg.EndIf();
|
|
}
|
|
inputParameterCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LoadZeroValueInputParametersIntoLocals(ParameterInfo[] parameters, LocalBuilder[] parameterLocals)
|
|
{
|
|
for (int i = 0; i < parameterLocals.Length; i++)
|
|
{
|
|
if (ServiceReflector.FlowsIn(parameters[i]))
|
|
{
|
|
ilg.LoadZeroValueIntoLocal(parameterLocals[i].LocalType, parameterLocals[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LoadTarget(ArgBuilder targetArg, Type targetType)
|
|
{
|
|
ilg.Load(targetArg);
|
|
ilg.ConvertValue(targetArg.ArgType, targetType);
|
|
if (targetType.IsValueType)
|
|
{
|
|
LocalBuilder targetLocal = ilg.DeclareLocal(targetType, "target");
|
|
ilg.Store(targetLocal);
|
|
ilg.LoadAddress(targetLocal);
|
|
}
|
|
}
|
|
|
|
void LoadParameters(ParameterInfo[] parameters, LocalBuilder[] parameterLocals)
|
|
{
|
|
for (int i = 0; i < parameterLocals.Length; i++)
|
|
{
|
|
if (parameters[i].ParameterType.IsByRef)
|
|
ilg.Ldloca(parameterLocals[i]);
|
|
else
|
|
ilg.Ldloc(parameterLocals[i]);
|
|
}
|
|
}
|
|
|
|
void InvokeMethod(MethodInfo method, LocalBuilder returnLocal)
|
|
{
|
|
ilg.Call(method);
|
|
if (method.ReturnType == typeof(void))
|
|
ilg.Load(null);
|
|
else
|
|
ilg.ConvertValue(method.ReturnType, ilg.CurrentMethod.ReturnType);
|
|
ilg.Store(returnLocal);
|
|
}
|
|
|
|
void LoadOutputParametersIntoArray(ParameterInfo[] parameters, LocalBuilder[] parameterLocals, ArgBuilder outputParametersArg, out int outputParameterCount)
|
|
{
|
|
outputParameterCount = 0;
|
|
for (int i = 0; i < parameterLocals.Length; i++)
|
|
{
|
|
if (ServiceReflector.FlowsOut(parameters[i]))
|
|
{
|
|
ilg.Load(outputParametersArg);
|
|
ilg.Load(outputParameterCount);
|
|
ilg.Load(parameterLocals[i]);
|
|
ilg.ConvertValue(parameterLocals[i].LocalType, TypeOfObject);
|
|
ilg.Stelem(TypeOfObject);
|
|
outputParameterCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool IsTypeVisible(Type t)
|
|
{
|
|
if (t.Module == typeof(InvokerUtil).Module)
|
|
return true;
|
|
|
|
if (!t.IsVisible)
|
|
return false;
|
|
|
|
foreach (Type genericType in t.GetGenericArguments())
|
|
{
|
|
if (!genericType.IsGenericParameter && !IsTypeVisible(genericType))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool ConstructorRequiresMemberAccess(ConstructorInfo ctor)
|
|
{
|
|
return ctor != null && (!ctor.IsPublic || !IsTypeVisible(ctor.DeclaringType)) && ctor.Module != typeof(InvokerUtil).Module;
|
|
}
|
|
|
|
static bool MethodRequiresMemberAccess(MethodInfo method)
|
|
{
|
|
return method != null && (!method.IsPublic || !IsTypeVisible(method.DeclaringType)) && method.Module != typeof(InvokerUtil).Module;
|
|
}
|
|
}
|
|
}
|
|
}
|