internal byte[] DoDispatch(byte[] reqStmBuff,
SmuggledMethodCallMessage smuggledMcm,
out SmuggledMethodReturnMessage smuggledMrm)
{
RemotingServices.LogRemotingStage(RemotingServices.SERVER_MSG_DESER);
//*********************** DE-SERIALIZE REQ-MSG ********************
IMessage desReqMsg = null;
if (smuggledMcm != null)
{
ArrayList deserializedArgs = smuggledMcm.FixupForNewAppDomain();
desReqMsg = new MethodCall(smuggledMcm, deserializedArgs);
}
else
{
MemoryStream reqStm = new MemoryStream(reqStmBuff);
desReqMsg = CrossAppDomainSerializer.DeserializeMessage(reqStm);
}
// now we can delegate to the DispatchMessage to do the rest
RemotingServices.LogRemotingStage(RemotingServices.SERVER_MSG_SINK_CHAIN);
IMessage retMsg = ChannelServices.SyncDispatchMessage(desReqMsg);
RemotingServices.LogRemotingStage(RemotingServices.SERVER_RET_SER);
smuggledMrm = SmuggledMethodReturnMessage.SmuggleIfPossible(retMsg);
if (smuggledMrm != null)
{
return(null);
}
else
{
if (retMsg != null)
{
// Null out the principal since we won't use it on the other side.
// This is handled inside of SmuggleIfPossible for method call
// messages.
LogicalCallContext callCtx = (LogicalCallContext)
retMsg.Properties[Message.CallContextKey];
if (callCtx != null)
{
if (callCtx.Principal != null)
{
callCtx.Principal = null;
}
}
return(CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer());
}
//*********************** SERIALIZE RET-MSG ********************
return(null);
}
} // DoDispatch
[System.Security.SecurityCritical] // auto-generated
internal static byte[] DoDispatch(byte[] reqStmBuff,
SmuggledMethodCallMessage smuggledMcm,
out SmuggledMethodReturnMessage smuggledMrm)
{
//*********************** DE-SERIALIZE REQ-MSG ********************
IMessage desReqMsg = null;
if (smuggledMcm != null)
{
ArrayList deserializedArgs = smuggledMcm.FixupForNewAppDomain();
desReqMsg = new MethodCall(smuggledMcm, deserializedArgs);
}
else
{
MemoryStream reqStm = new MemoryStream(reqStmBuff);
desReqMsg = CrossAppDomainSerializer.DeserializeMessage(reqStm);
}
LogicalCallContext lcc = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
lcc.SetData(LCC_DATA_KEY, true);
// now we can delegate to the DispatchMessage to do the rest
IMessage retMsg = ChannelServices.SyncDispatchMessage(desReqMsg);
lcc.FreeNamedDataSlot(LCC_DATA_KEY);
smuggledMrm = SmuggledMethodReturnMessage.SmuggleIfPossible(retMsg);
if (smuggledMrm != null)
{
return(null);
}
else
{
if (retMsg != null)
{
// Null out the principal since we won't use it on the other side.
// This is handled inside of SmuggleIfPossible for method call
// messages.
LogicalCallContext callCtx = (LogicalCallContext)
retMsg.Properties[Message.CallContextKey];
if (callCtx != null)
{
if (callCtx.Principal != null)
{
callCtx.Principal = null;
}
}
return(CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer());
}
//*********************** SERIALIZE RET-MSG ********************
return(null);
}
} // DoDispatch
} // DoDispatch
internal byte[] DoTransitionDispatch(
byte[] reqStmBuff,
SmuggledMethodCallMessage smuggledMcm,
out SmuggledMethodReturnMessage smuggledMrm)
{
// Note: To be safe w.r.t. the app domain leak code, this frame
// should have no non-agile references in it.
ContextTransitionFrame frame = new ContextTransitionFrame();
// change to server domain
Thread.CurrentThread.EnterContextInternal(
null,
_srvContextID,
_srvDomainID,
ref frame);
byte[] retBuff = null;
smuggledMrm = null;
try
{
Message.DebugOut("#### : changed to Server Domain :: " + (Thread.CurrentContext.InternalContextID).ToString("X"));
retBuff = DoDispatch(reqStmBuff, smuggledMcm, out smuggledMrm);
}
catch (Exception e)
{
// This will catch exceptions thrown by the infrastructure,
// Serialization/Deserialization etc
// Those thrown by the server are already taken care of
// and encoded in the retMsg .. so we don't come here for
// that case.
// We are in another appDomain, so we can't simply throw
// the exception object across. The following marshals it
// into a serialized return message.
IMessage retMsg =
new ReturnMessage(e, new ErrorMessage());
//*********************** SERIALIZE RET-MSG ******************
retBuff = CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer();
retMsg = null;
}
finally
{
RemotingServices.LogRemotingStage(RemotingServices.SERVER_RET_SEND);
Thread.CurrentThread.ReturnToContext(ref frame);
Message.DebugOut("#### : changed back to Client Domain " + (Thread.CurrentContext.InternalContextID).ToString("X"));
}
// System.Diagnostics.Debugger.Break();
return(retBuff);
} // DoTransitionDispatch
internal static object DoTransitionDispatchCallback(object[] args)
{
byte[] reqStmBuff = (byte[])args[0];
SmuggledMethodCallMessage smuggledMcm = (SmuggledMethodCallMessage)args[1];
SmuggledMethodReturnMessage smuggledMethodReturnMessage = null;
byte[] result = null;
try
{
result = CrossAppDomainSink.DoDispatch(reqStmBuff, smuggledMcm, out smuggledMethodReturnMessage);
}
catch (Exception e)
{
IMessage msg = new ReturnMessage(e, new ErrorMessage());
result = CrossAppDomainSerializer.SerializeMessage(msg).GetBuffer();
}
args[2] = smuggledMethodReturnMessage;
return(result);
}
internal static object DoTransitionDispatchCallback(object[] args)
{
byte[] reqStmBuff = (byte[])args[0];
SmuggledMethodCallMessage smuggledMcm = (SmuggledMethodCallMessage)args[1];
SmuggledMethodReturnMessage smuggledMrm = (SmuggledMethodReturnMessage)null;
byte[] numArray;
try
{
numArray = CrossAppDomainSink.DoDispatch(reqStmBuff, smuggledMcm, out smuggledMrm);
}
catch (Exception ex)
{
ErrorMessage errorMessage = new ErrorMessage();
numArray = CrossAppDomainSerializer.SerializeMessage((IMessage) new ReturnMessage(ex, (IMethodCallMessage)errorMessage)).GetBuffer();
}
args[2] = (object)smuggledMrm;
return((object)numArray);
}
internal static object DoTransitionDispatchCallback(object[] args)
{
byte[] reqStmBuff = (byte[])args[0];
SmuggledMethodCallMessage smuggledMcm = (SmuggledMethodCallMessage)args[1];
SmuggledMethodReturnMessage smuggledMrm = null;
byte[] buffer = null;
try
{
buffer = DoDispatch(reqStmBuff, smuggledMcm, out smuggledMrm);
}
catch (Exception exception)
{
IMessage msg = new ReturnMessage(exception, new ErrorMessage());
buffer = CrossAppDomainSerializer.SerializeMessage(msg).GetBuffer();
msg = null;
}
args[2] = smuggledMrm;
return(buffer);
}
internal static byte[] DoDispatch(byte[] reqStmBuff, SmuggledMethodCallMessage smuggledMcm, out SmuggledMethodReturnMessage smuggledMrm)
{
IMessage msg1;
if (smuggledMcm != null)
{
ArrayList deserializedArgs = smuggledMcm.FixupForNewAppDomain();
msg1 = (IMessage) new MethodCall(smuggledMcm, deserializedArgs);
}
else
{
msg1 = CrossAppDomainSerializer.DeserializeMessage(new MemoryStream(reqStmBuff));
}
LogicalCallContext logicalCallContext1 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
string name1 = "__xADCall";
// ISSUE: variable of a boxed type
__Boxed <bool> local = (ValueType)true;
logicalCallContext1.SetData(name1, (object)local);
IMessage msg2 = ChannelServices.SyncDispatchMessage(msg1);
string name2 = "__xADCall";
logicalCallContext1.FreeNamedDataSlot(name2);
smuggledMrm = SmuggledMethodReturnMessage.SmuggleIfPossible(msg2);
if (smuggledMrm != null)
{
return((byte[])null);
}
if (msg2 == null)
{
return((byte[])null);
}
LogicalCallContext logicalCallContext2 = (LogicalCallContext)msg2.Properties[(object)Message.CallContextKey];
if (logicalCallContext2 != null && logicalCallContext2.Principal != null)
{
logicalCallContext2.Principal = (IPrincipal)null;
}
return(CrossAppDomainSerializer.SerializeMessage(msg2).GetBuffer());
}
internal byte[] DoTransitionDispatch(
byte[] reqStmBuff,
SmuggledMethodCallMessage smuggledMcm,
out SmuggledMethodReturnMessage smuggledMrm)
{
byte[] retBuff = null;
Object[] args = new Object[] { reqStmBuff, smuggledMcm, null };
retBuff = (byte[])Thread.CurrentThread.InternalCrossContextCallback(null,
_xadData.ContextID,
_xadData.DomainID,
s_xctxDel,
args);
Message.DebugOut("#### : changed back to Client Domain " + (Thread.CurrentContext.InternalContextID).ToString("X"));
smuggledMrm = (SmuggledMethodReturnMessage)args[2];
// System.Diagnostics.Debugger.Break();
return(retBuff);
} // DoTransitionDispatch
[System.Security.SecurityCritical] // auto-generated
internal static Object DoTransitionDispatchCallback(Object[] args)
{
byte[] reqStmBuff = (byte[])args[0];
SmuggledMethodCallMessage smuggledMcm = (SmuggledMethodCallMessage)args[1];
SmuggledMethodReturnMessage smuggledMrm = null;
byte[] retBuff = null;
try
{
#if !FEATURE_CORECLR
Message.DebugOut("#### : changed to Server Domain :: " + (Thread.CurrentContext.InternalContextID).ToString("X"));
#endif
retBuff = DoDispatch(reqStmBuff, smuggledMcm, out smuggledMrm);
}
catch (Exception e)
{
// This will catch exceptions thrown by the infrastructure,
// Serialization/Deserialization etc
// Those thrown by the server are already taken care of
// and encoded in the retMsg .. so we don't come here for
// that case.
// We are in another appDomain, so we can't simply throw
// the exception object across. The following marshals it
// into a serialized return message.
IMessage retMsg =
new ReturnMessage(e, new ErrorMessage());
//*********************** SERIALIZE RET-MSG ******************
retBuff = CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer();
retMsg = null;
}
args[2] = smuggledMrm;
return(retBuff);
}
internal static byte[] DoDispatch(byte[] reqStmBuff, SmuggledMethodCallMessage smuggledMcm, out SmuggledMethodReturnMessage smuggledMrm)
{
IMessage msg = null;
if (smuggledMcm != null)
{
ArrayList deserializedArgs = smuggledMcm.FixupForNewAppDomain();
msg = new MethodCall(smuggledMcm, deserializedArgs);
}
else
{
MemoryStream stm = new MemoryStream(reqStmBuff);
msg = CrossAppDomainSerializer.DeserializeMessage(stm);
}
LogicalCallContext logicalCallContext = CallContext.GetLogicalCallContext();
logicalCallContext.SetData("__xADCall", true);
IMessage message2 = ChannelServices.SyncDispatchMessage(msg);
logicalCallContext.FreeNamedDataSlot("__xADCall");
smuggledMrm = SmuggledMethodReturnMessage.SmuggleIfPossible(message2);
if (smuggledMrm != null)
{
return(null);
}
if (message2 == null)
{
return(null);
}
LogicalCallContext context2 = (LogicalCallContext)message2.Properties[Message.CallContextKey];
if ((context2 != null) && (context2.Principal != null))
{
context2.Principal = null;
}
return(CrossAppDomainSerializer.SerializeMessage(message2).GetBuffer());
}
internal byte[] DoTransitionDispatch(byte[] reqStmBuff, SmuggledMethodCallMessage smuggledMcm, out SmuggledMethodReturnMessage smuggledMrm)
{
object[] array = new object[3];
array[0] = reqStmBuff;
array[1] = smuggledMcm;
object[] array2 = array;
byte[] result = (byte[])Thread.CurrentThread.InternalCrossContextCallback(null, this._xadData.ContextID, this._xadData.DomainID, CrossAppDomainSink.s_xctxDel, array2);
smuggledMrm = (SmuggledMethodReturnMessage)array2[2];
return(result);
}
internal byte[] DoTransitionDispatch(byte[] reqStmBuff, SmuggledMethodCallMessage smuggledMcm, out SmuggledMethodReturnMessage smuggledMrm)
{
byte[] buffer = null;
object[] objArray2 = new object[3];
objArray2[0] = reqStmBuff;
objArray2[1] = smuggledMcm;
object[] args = objArray2;
buffer = (byte[])Thread.CurrentThread.InternalCrossContextCallback(null, this._xadData.ContextID, this._xadData.DomainID, s_xctxDel, args);
smuggledMrm = (SmuggledMethodReturnMessage)args[2];
return(buffer);
}
[System.Security.SecurityCritical] // auto-generated
internal MethodResponse(IMethodCallMessage msg,
SmuggledMethodReturnMessage smuggledMrm,
ArrayList deserializedArgs)
{
MI = (MethodBase)msg.MethodBase;
_methodCache = InternalRemotingServices.GetReflectionCachedData(MI);
methodName = msg.MethodName;
uri = msg.Uri;
typeName = msg.TypeName;
if (_methodCache.IsOverloaded())
methodSignature = (Type[])msg.MethodSignature;
retVal = smuggledMrm.GetReturnValue(deserializedArgs);
outArgs = smuggledMrm.GetArgs(deserializedArgs);
fault = smuggledMrm.GetException(deserializedArgs);
callContext = smuggledMrm.GetCallContext(deserializedArgs);
if (smuggledMrm.MessagePropertyCount > 0)
smuggledMrm.PopulateMessageProperties(Properties, deserializedArgs);
argCount = _methodCache.Parameters.Length;
fSoap = false;
}
internal byte[] DoTransitionDispatch(byte[] reqStmBuff, SmuggledMethodCallMessage smuggledMcm, out SmuggledMethodReturnMessage smuggledMrm)
{
object[] args = new object[3] {
(object)reqStmBuff, (object)smuggledMcm, null
};
byte[] numArray = (byte[])Thread.CurrentThread.InternalCrossContextCallback((Context)null, this._xadData.ContextID, this._xadData.DomainID, CrossAppDomainSink.s_xctxDel, args);
smuggledMrm = (SmuggledMethodReturnMessage)args[2];
return(numArray);
}
