Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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;
}
}
}
}