|
static private SetLogicalCallContext ( |
||
| callCtx | ||
| return | ||
internal static LogicalCallContext PropagateCallContextFromMessageToThread(IMessage msg)
{
return(CallContext.SetLogicalCallContext((LogicalCallContext)msg.Properties[Message.CallContextKey]));
}
internal static void PropagateCallContextFromThreadToMessage(IMessage msg, LogicalCallContext oldcctx)
{
Message.PropagateCallContextFromThreadToMessage(msg);
CallContext.SetLogicalCallContext(oldcctx);
}
public virtual IMessageCtrl AsyncProcessMessage(
IMessage msg, IMessageSink replySink)
{
IMethodCallMessage mcMsg = (IMethodCallMessage)msg;
IMessageCtrl retCtrl = null;
IMessage retMessage = null;
LogicalCallContext oldCallCtx = null;
try
{
LogicalCallContext callCtx = (LogicalCallContext)
mcMsg.Properties[Message.CallContextKey];
Object server = _server;
// validate the method base if necessary
VerifyIsOkToCallMethod(server, mcMsg);
// install call context onto the thread, holding onto
// the one that is currently on the thread
oldCallCtx = CallContext.SetLogicalCallContext(callCtx);
// retrieve incoming headers
callCtx.PropagateIncomingHeadersToCallContext(msg);
PreserveThreadPrincipalIfNecessary(callCtx, oldCallCtx);
// see if this is a server message that was dispatched asynchronously
ServerChannelSinkStack sinkStack =
msg.Properties["__SinkStack"] as ServerChannelSinkStack;
if (sinkStack != null)
{
sinkStack.ServerObject = server;
}
BCLDebug.Assert((server != null) == (!_bStatic),
"Invalid state in stackbuilder sink?");
MethodBase mb = GetMethodBase(mcMsg);
Object[] outArgs = null;
Object ret = null;
RemotingMethodCachedData methodCache =
InternalRemotingServices.GetReflectionCachedData(mb);
Object[] args = Message.CoerceArgs(mcMsg, methodCache.Parameters);
ret = PrivateProcessMessage(mb,
args,
server,
0,
false,
out outArgs);
CopyNonByrefOutArgsFromOriginalArgs(methodCache, args, ref outArgs);
if (replySink != null)
{
// call context could be different then the one from before the call.
LogicalCallContext latestCallContext = CallContext.GetLogicalCallContext();
retMessage = new ReturnMessage(
ret,
outArgs,
(outArgs == null ? 0 : outArgs.Length),
latestCallContext,
mcMsg);
// retrieve outgoing response headers
latestCallContext.PropagateOutgoingHeadersToMessage(retMessage);
replySink.SyncProcessMessage(retMessage);
}
}
catch (Exception e)
{
try
{
if (replySink != null)
{
retMessage = new ReturnMessage(e, mcMsg);
((ReturnMessage)retMessage).SetLogicalCallContext(
(LogicalCallContext)
mcMsg.Properties[Message.CallContextKey]);
replySink.SyncProcessMessage(retMessage);
}
}
catch (Exception)
{
// Fatal error.. can't do anything ..
// bail out silently.
}
}
finally
{
// restore the call context on the thread
if (oldCallCtx != null)
{
CallContext.SetLogicalCallContext(oldCallCtx);
}
}
return(retCtrl);
} // AsyncProcessMessage
internal virtual IMessage SyncProcessMessage(IMessage msg, int methodPtr, bool fExecuteInContext)
{
// Validate message here
IMessage errMsg = InternalSink.ValidateMessage(msg);
if (errMsg != null)
{
return(errMsg);
}
IMethodCallMessage mcMsg = msg as IMethodCallMessage;
IMessage retMessage;
LogicalCallContext oldCallCtx = null;
try
{
Object server = _server;
BCLDebug.Assert((server != null) == (!_bStatic),
"Invalid state in stackbuilder sink?");
// validate the method base if necessary
VerifyIsOkToCallMethod(server, mcMsg);
// install call context onto the thread, holding onto
// the one that is currently on the thread
LogicalCallContext messageCallContext = null;
if (mcMsg != null)
{
messageCallContext = mcMsg.LogicalCallContext;
}
else
{
messageCallContext = (LogicalCallContext)msg.Properties["__CallContext"];
}
oldCallCtx = CallContext.SetLogicalCallContext(messageCallContext);
messageCallContext.PropagateIncomingHeadersToCallContext(msg);
PreserveThreadPrincipalIfNecessary(messageCallContext, oldCallCtx);
// NOTE: target for dispatch will be NULL when the StackBuilderSink
// is used for async delegates on static methods.
RemotingServices.LogRemotingStage(RemotingServices.SERVER_MSG_STACK_BUILD);
// *** NOTE ***
// Although we always pass _server to these calls in the EE,
// when we execute using Message::Dispatch we are using TP as
// the this-ptr ... (what the call site thinks is the this-ptr)
// when we execute using StackBuilderSink::PrivatePM we use
// _server as the this-ptr (which could be different if there
// is interception for strictly MBR types in the same AD).
// ************
if (IsOKToStackBlt(mcMsg, server) &&
((Message)mcMsg).Dispatch(server, fExecuteInContext))
{
//retMessage = StackBasedReturnMessage.GetObjectFromPool((Message)mcMsg);
retMessage = new StackBasedReturnMessage();
((StackBasedReturnMessage)retMessage).InitFields((Message)mcMsg);
// call context could be different then the one from before the call.
LogicalCallContext latestCallContext = CallContext.GetLogicalCallContext();
// retrieve outgoing response headers
latestCallContext.PropagateOutgoingHeadersToMessage(retMessage);
// Install call context back into Message (from the thread)
((StackBasedReturnMessage)retMessage).SetLogicalCallContext(latestCallContext);
}
else
{
MethodBase mb = GetMethodBase(mcMsg);
Object[] outArgs = null;
Object ret = null;
RemotingMethodCachedData methodCache =
InternalRemotingServices.GetReflectionCachedData(mb);
Message.DebugOut("StackBuilderSink::Calling PrivateProcessMessage\n");
Object[] args = Message.CoerceArgs(mcMsg, methodCache.Parameters);
ret = PrivateProcessMessage(
mb,
args,
server,
methodPtr,
fExecuteInContext,
out outArgs);
CopyNonByrefOutArgsFromOriginalArgs(methodCache, args, ref outArgs);
// call context could be different then the one from before the call.
LogicalCallContext latestCallContext = CallContext.GetLogicalCallContext();
retMessage = new ReturnMessage(
ret,
outArgs,
(outArgs == null ? 0 : outArgs.Length),
latestCallContext,
mcMsg);
// retrieve outgoing response headers
latestCallContext.PropagateOutgoingHeadersToMessage(retMessage);
}
// restore the call context on the thread
CallContext.SetLogicalCallContext(oldCallCtx);
} catch (Exception e)
{
Message.DebugOut(
"StackBuilderSink::The server object probably threw an exception " +
e.Message + e.StackTrace + "\n");
retMessage = new ReturnMessage(e, mcMsg);
((ReturnMessage)retMessage).SetLogicalCallContext(mcMsg.LogicalCallContext);
if (oldCallCtx != null)
{
CallContext.SetLogicalCallContext(oldCallCtx);
}
}
RemotingServices.LogRemotingStage(RemotingServices.SERVER_RET_SINK_CHAIN);
return(retMessage);
}
internal static void PropagateCallContextFromThreadToMessage(IMessage msg, System.Runtime.Remoting.Messaging.LogicalCallContext oldcctx)
{
PropagateCallContextFromThreadToMessage(msg);
CallContext.SetLogicalCallContext(oldcctx);
}
[System.Security.SecurityCritical] // auto-generated
public virtual IMessageCtrl AsyncProcessMessage(
IMessage msg, IMessageSink replySink)
{
IMethodCallMessage mcMsg = (IMethodCallMessage)msg;
IMessageCtrl retCtrl = null;
IMessage retMessage = null;
LogicalCallContext oldCallCtx = null;
bool isCallContextSet = false;
try{
try
{
LogicalCallContext callCtx = (LogicalCallContext)
mcMsg.Properties[Message.CallContextKey];
Object server = _server;
// validate the method base if necessary
VerifyIsOkToCallMethod(server, mcMsg);
// install call context onto the thread, holding onto
// the one that is currently on the thread
oldCallCtx = CallContext.SetLogicalCallContext(callCtx);
isCallContextSet = true;
// retrieve incoming headers
callCtx.PropagateIncomingHeadersToCallContext(msg);
PreserveThreadPrincipalIfNecessary(callCtx, oldCallCtx);
// see if this is a server message that was dispatched asynchronously
ServerChannelSinkStack sinkStack =
msg.Properties["__SinkStack"] as ServerChannelSinkStack;
if (sinkStack != null)
{
sinkStack.ServerObject = server;
}
BCLDebug.Assert((server != null) == (!_bStatic),
"Invalid state in stackbuilder sink?");
MethodBase mb = GetMethodBase(mcMsg);
Object[] outArgs = null;
Object ret = null;
RemotingMethodCachedData methodCache =
InternalRemotingServices.GetReflectionCachedData(mb);
Object[] args = Message.CoerceArgs(mcMsg, methodCache.Parameters);
ret = PrivateProcessMessage(mb.MethodHandle,
args,
server,
0,
false,
out outArgs);
CopyNonByrefOutArgsFromOriginalArgs(methodCache, args, ref outArgs);
if (replySink != null)
{
// call context could be different then the one from before the call.
LogicalCallContext latestCallContext = CallContext.GetLogicalCallContext();
if (latestCallContext != null)
{
// Special case Principal since if might not be serializable before returning
// ReturnMessage
latestCallContext.RemovePrincipalIfNotSerializable();
}
retMessage = new ReturnMessage(
ret,
outArgs,
(outArgs == null ? 0 : outArgs.Length),
latestCallContext,
mcMsg);
// retrieve outgoing response headers
latestCallContext.PropagateOutgoingHeadersToMessage(retMessage);
}
}
catch (Exception e)
{
if (replySink != null)
{
retMessage = new ReturnMessage(e, mcMsg);
((ReturnMessage)retMessage).SetLogicalCallContext(
(LogicalCallContext)
mcMsg.Properties[Message.CallContextKey]);
}
}
finally
{
if (replySink != null)
{
// Call the reply sink without catching the exceptions
// in it. In v2.0 any exceptions in the callback for example
// would probably bring down the process
replySink.SyncProcessMessage(retMessage);
}
}
}
finally {
// restore the call context on the thread
if (isCallContextSet)
{
CallContext.SetLogicalCallContext(oldCallCtx);
}
}
return(retCtrl);
} // AsyncProcessMessage
public virtual IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodCallMessage message = (IMethodCallMessage)msg;
IMessageCtrl ctrl = null;
IMessage message2 = null;
LogicalCallContext threadCallContext = null;
bool flag = false;
try
{
try
{
try
{
LogicalCallContext callCtx = (LogicalCallContext)message.Properties[Message.CallContextKey];
object server = this._server;
VerifyIsOkToCallMethod(server, message);
threadCallContext = CallContext.SetLogicalCallContext(callCtx);
flag = true;
callCtx.PropagateIncomingHeadersToCallContext(msg);
PreserveThreadPrincipalIfNecessary(callCtx, threadCallContext);
ServerChannelSinkStack stack = msg.Properties["__SinkStack"] as ServerChannelSinkStack;
if (stack != null)
{
stack.ServerObject = server;
}
MethodBase methodBase = GetMethodBase(message);
object[] outArgs = null;
object ret = null;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
object[] args = Message.CoerceArgs(message, reflectionCachedData.Parameters);
ret = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, 0, false, out outArgs);
this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs);
if (replySink != null)
{
LogicalCallContext logicalCallContext = CallContext.GetLogicalCallContext();
if (logicalCallContext != null)
{
logicalCallContext.RemovePrincipalIfNotSerializable();
}
message2 = new ReturnMessage(ret, outArgs, (outArgs == null) ? 0 : outArgs.Length, logicalCallContext, message);
logicalCallContext.PropagateOutgoingHeadersToMessage(message2);
}
return(ctrl);
}
catch (Exception exception)
{
if (replySink != null)
{
message2 = new ReturnMessage(exception, message);
((ReturnMessage)message2).SetLogicalCallContext((LogicalCallContext)message.Properties[Message.CallContextKey]);
}
}
return(ctrl);
}
finally
{
if (replySink != null)
{
replySink.SyncProcessMessage(message2);
}
}
}
finally
{
if (flag)
{
CallContext.SetLogicalCallContext(threadCallContext);
}
}
return(ctrl);
}
internal static System.Runtime.Remoting.Messaging.LogicalCallContext PropagateCallContextFromMessageToThread(IMessage msg)
{
return(CallContext.SetLogicalCallContext((System.Runtime.Remoting.Messaging.LogicalCallContext)msg.Properties[CallContextKey]));
}
internal virtual IMessage SyncProcessMessage(IMessage msg, int methodPtr, bool fExecuteInContext)
{
IMessage message3;
IMessage message = InternalSink.ValidateMessage(msg);
if (message != null)
{
return(message);
}
IMethodCallMessage message2 = msg as IMethodCallMessage;
LogicalCallContext threadCallContext = null;
object obj2 = CallContext.GetLogicalCallContext().GetData("__xADCall");
bool flag = false;
try
{
object server = this._server;
VerifyIsOkToCallMethod(server, message2);
LogicalCallContext callCtx = null;
if (message2 != null)
{
callCtx = message2.LogicalCallContext;
}
else
{
callCtx = (LogicalCallContext)msg.Properties["__CallContext"];
}
threadCallContext = CallContext.SetLogicalCallContext(callCtx);
flag = true;
callCtx.PropagateIncomingHeadersToCallContext(msg);
PreserveThreadPrincipalIfNecessary(callCtx, threadCallContext);
if (this.IsOKToStackBlt(message2, server) && ((Message)message2).Dispatch(server, fExecuteInContext))
{
message3 = new StackBasedReturnMessage();
((StackBasedReturnMessage)message3).InitFields((Message)message2);
LogicalCallContext context4 = CallContext.GetLogicalCallContext();
context4.PropagateOutgoingHeadersToMessage(message3);
((StackBasedReturnMessage)message3).SetLogicalCallContext(context4);
return(message3);
}
MethodBase methodBase = GetMethodBase(message2);
object[] outArgs = null;
object ret = null;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
object[] args = Message.CoerceArgs(message2, reflectionCachedData.Parameters);
ret = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, methodPtr, fExecuteInContext, out outArgs);
this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs);
LogicalCallContext logicalCallContext = CallContext.GetLogicalCallContext();
if (((obj2 != null) && ((bool)obj2)) && (logicalCallContext != null))
{
logicalCallContext.RemovePrincipalIfNotSerializable();
}
message3 = new ReturnMessage(ret, outArgs, (outArgs == null) ? 0 : outArgs.Length, logicalCallContext, message2);
logicalCallContext.PropagateOutgoingHeadersToMessage(message3);
CallContext.SetLogicalCallContext(threadCallContext);
}
catch (Exception exception)
{
message3 = new ReturnMessage(exception, message2);
((ReturnMessage)message3).SetLogicalCallContext(message2.LogicalCallContext);
if (flag)
{
CallContext.SetLogicalCallContext(threadCallContext);
}
}
return(message3);
}
public virtual IMessage SyncProcessMessage(IMessage msg)
{
IMessage message = InternalSink.ValidateMessage(msg);
if (message != null)
{
return(message);
}
IMethodCallMessage methodCallMessage = msg as IMethodCallMessage;
LogicalCallContext logicalCallContext = null;
LogicalCallContext logicalCallContext2 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
object data = logicalCallContext2.GetData("__xADCall");
bool flag = false;
IMessage message2;
try
{
object server = this._server;
StackBuilderSink.VerifyIsOkToCallMethod(server, methodCallMessage);
LogicalCallContext logicalCallContext3;
if (methodCallMessage != null)
{
logicalCallContext3 = methodCallMessage.LogicalCallContext;
}
else
{
logicalCallContext3 = (LogicalCallContext)msg.Properties["__CallContext"];
}
logicalCallContext = CallContext.SetLogicalCallContext(logicalCallContext3);
flag = true;
logicalCallContext3.PropagateIncomingHeadersToCallContext(msg);
StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext3, logicalCallContext);
if (this.IsOKToStackBlt(methodCallMessage, server) && ((Message)methodCallMessage).Dispatch(server))
{
message2 = new StackBasedReturnMessage();
((StackBasedReturnMessage)message2).InitFields((Message)methodCallMessage);
LogicalCallContext logicalCallContext4 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
logicalCallContext4.PropagateOutgoingHeadersToMessage(message2);
((StackBasedReturnMessage)message2).SetLogicalCallContext(logicalCallContext4);
}
else
{
MethodBase methodBase = StackBuilderSink.GetMethodBase(methodCallMessage);
object[] array = null;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
object[] args = Message.CoerceArgs(methodCallMessage, reflectionCachedData.Parameters);
object ret = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, out array);
this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref array);
LogicalCallContext logicalCallContext5 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
if (data != null && (bool)data && logicalCallContext5 != null)
{
logicalCallContext5.RemovePrincipalIfNotSerializable();
}
message2 = new ReturnMessage(ret, array, (array == null) ? 0 : array.Length, logicalCallContext5, methodCallMessage);
logicalCallContext5.PropagateOutgoingHeadersToMessage(message2);
CallContext.SetLogicalCallContext(logicalCallContext);
}
}
catch (Exception e)
{
message2 = new ReturnMessage(e, methodCallMessage);
((ReturnMessage)message2).SetLogicalCallContext(methodCallMessage.LogicalCallContext);
if (flag)
{
CallContext.SetLogicalCallContext(logicalCallContext);
}
}
return(message2);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodCallMessage methodCallMessage = (IMethodCallMessage)msg;
IMessageCtrl result = null;
IMessage message = null;
LogicalCallContext logicalCallContext = null;
bool flag = false;
try
{
try
{
LogicalCallContext logicalCallContext2 = (LogicalCallContext)methodCallMessage.Properties[Message.CallContextKey];
object server = this._server;
StackBuilderSink.VerifyIsOkToCallMethod(server, methodCallMessage);
logicalCallContext = CallContext.SetLogicalCallContext(logicalCallContext2);
flag = true;
logicalCallContext2.PropagateIncomingHeadersToCallContext(msg);
StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext2, logicalCallContext);
ServerChannelSinkStack serverChannelSinkStack = msg.Properties["__SinkStack"] as ServerChannelSinkStack;
if (serverChannelSinkStack != null)
{
serverChannelSinkStack.ServerObject = server;
}
MethodBase methodBase = StackBuilderSink.GetMethodBase(methodCallMessage);
object[] array = null;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
object[] args = Message.CoerceArgs(methodCallMessage, reflectionCachedData.Parameters);
object ret = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, out array);
this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref array);
if (replySink != null)
{
LogicalCallContext logicalCallContext3 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
if (logicalCallContext3 != null)
{
logicalCallContext3.RemovePrincipalIfNotSerializable();
}
message = new ReturnMessage(ret, array, (array == null) ? 0 : array.Length, logicalCallContext3, methodCallMessage);
logicalCallContext3.PropagateOutgoingHeadersToMessage(message);
}
}
catch (Exception e)
{
if (replySink != null)
{
message = new ReturnMessage(e, methodCallMessage);
((ReturnMessage)message).SetLogicalCallContext((LogicalCallContext)methodCallMessage.Properties[Message.CallContextKey]);
}
}
finally
{
if (replySink != null)
{
replySink.SyncProcessMessage(message);
}
}
}
finally
{
if (flag)
{
CallContext.SetLogicalCallContext(logicalCallContext);
}
}
return(result);
}
public virtual IMessage SyncProcessMessage(IMessage msg)
{
IMessage message = InternalSink.ValidateMessage(msg);
if (message != null)
{
return(message);
}
IMethodCallMessage methodCallMessage = msg as IMethodCallMessage;
LogicalCallContext logicalCallContext1 = (LogicalCallContext)null;
object data = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.GetData("__xADCall");
bool flag = false;
IMessage msg1;
try
{
object obj = this._server;
StackBuilderSink.VerifyIsOkToCallMethod(obj, (IMethodMessage)methodCallMessage);
LogicalCallContext logicalCallContext2 = methodCallMessage == null ? (LogicalCallContext)msg.Properties[(object)"__CallContext"] : methodCallMessage.LogicalCallContext;
logicalCallContext1 = CallContext.SetLogicalCallContext(logicalCallContext2);
flag = true;
logicalCallContext2.PropagateIncomingHeadersToCallContext(msg);
StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext2, logicalCallContext1);
if (this.IsOKToStackBlt((IMethodMessage)methodCallMessage, obj) && ((Message)methodCallMessage).Dispatch(obj))
{
msg1 = (IMessage) new StackBasedReturnMessage();
((StackBasedReturnMessage)msg1).InitFields((Message)methodCallMessage);
LogicalCallContext logicalCallContext3 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
logicalCallContext3.PropagateOutgoingHeadersToMessage(msg1);
((StackBasedReturnMessage)msg1).SetLogicalCallContext(logicalCallContext3);
}
else
{
MethodBase methodBase = StackBuilderSink.GetMethodBase((IMethodMessage)methodCallMessage);
object[] outArgs1 = (object[])null;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
object[] args = Message.CoerceArgs((IMethodMessage)methodCallMessage, reflectionCachedData.Parameters);
object ret = this.PrivateProcessMessage(methodBase.MethodHandle, args, obj, out outArgs1);
this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs1);
LogicalCallContext logicalCallContext3 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
if (data != null && (bool)data && logicalCallContext3 != null)
{
logicalCallContext3.RemovePrincipalIfNotSerializable();
}
object[] outArgs2 = outArgs1;
int outArgsCount = outArgs2 == null ? 0 : outArgs1.Length;
LogicalCallContext callCtx = logicalCallContext3;
IMethodCallMessage mcm = methodCallMessage;
msg1 = (IMessage) new ReturnMessage(ret, outArgs2, outArgsCount, callCtx, mcm);
logicalCallContext3.PropagateOutgoingHeadersToMessage(msg1);
CallContext.SetLogicalCallContext(logicalCallContext1);
}
}
catch (Exception ex)
{
IMethodCallMessage mcm = methodCallMessage;
msg1 = (IMessage) new ReturnMessage(ex, mcm);
((ReturnMessage)msg1).SetLogicalCallContext(methodCallMessage.LogicalCallContext);
if (flag)
{
CallContext.SetLogicalCallContext(logicalCallContext1);
}
}
return(msg1);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodCallMessage mcm1 = (IMethodCallMessage)msg;
IMessageCtrl messageCtrl = (IMessageCtrl)null;
IMessage msg1 = (IMessage)null;
LogicalCallContext callCtx1 = (LogicalCallContext)null;
bool flag = false;
try
{
try
{
LogicalCallContext logicalCallContext1 = (LogicalCallContext)mcm1.Properties[(object)Message.CallContextKey];
object server = this._server;
StackBuilderSink.VerifyIsOkToCallMethod(server, (IMethodMessage)mcm1);
callCtx1 = CallContext.SetLogicalCallContext(logicalCallContext1);
flag = true;
IMessage msg2 = msg;
logicalCallContext1.PropagateIncomingHeadersToCallContext(msg2);
LogicalCallContext threadCallContext = callCtx1;
StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext1, threadCallContext);
ServerChannelSinkStack channelSinkStack = msg.Properties[(object)"__SinkStack"] as ServerChannelSinkStack;
if (channelSinkStack != null)
{
channelSinkStack.ServerObject = server;
}
MethodBase methodBase = StackBuilderSink.GetMethodBase((IMethodMessage)mcm1);
object[] outArgs1 = (object[])null;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
object[] args = Message.CoerceArgs((IMethodMessage)mcm1, reflectionCachedData.Parameters);
object obj = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, out outArgs1);
this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs1);
if (replySink != null)
{
LogicalCallContext logicalCallContext2 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
if (logicalCallContext2 != null)
{
logicalCallContext2.RemovePrincipalIfNotSerializable();
}
object ret = obj;
object[] outArgs2 = outArgs1;
int outArgsCount = outArgs2 == null ? 0 : outArgs1.Length;
LogicalCallContext callCtx2 = logicalCallContext2;
IMethodCallMessage mcm2 = mcm1;
msg1 = (IMessage) new ReturnMessage(ret, outArgs2, outArgsCount, callCtx2, mcm2);
logicalCallContext2.PropagateOutgoingHeadersToMessage(msg1);
}
}
catch (Exception ex)
{
if (replySink != null)
{
msg1 = (IMessage) new ReturnMessage(ex, mcm1);
((ReturnMessage)msg1).SetLogicalCallContext((LogicalCallContext)mcm1.Properties[(object)Message.CallContextKey]);
}
}
finally
{
if (replySink != null)
{
replySink.SyncProcessMessage(msg1);
}
}
}
finally
{
if (flag)
{
CallContext.SetLogicalCallContext(callCtx1);
}
}
return(messageCtrl);
}