public virtual IMessage SyncProcessMessage(IMessage reqMsg)
{
IMessage message = InternalSink.ValidateMessage(reqMsg);
if (message != null)
{
return(message);
}
IPrincipal principal = null;
IMessage message2 = null;
try
{
IMethodCallMessage methodCallMessage = reqMsg as IMethodCallMessage;
if (methodCallMessage != null)
{
LogicalCallContext logicalCallContext = methodCallMessage.LogicalCallContext;
if (logicalCallContext != null)
{
principal = logicalCallContext.RemovePrincipalIfNotSerializable();
}
}
MemoryStream memoryStream = null;
SmuggledMethodCallMessage smuggledMethodCallMessage = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
if (smuggledMethodCallMessage == null)
{
memoryStream = CrossAppDomainSerializer.SerializeMessage(reqMsg);
}
LogicalCallContext logicalCallContext2 = CallContext.SetLogicalCallContext(null);
byte[] array = null;
SmuggledMethodReturnMessage smuggledMethodReturnMessage;
try
{
if (smuggledMethodCallMessage != null)
{
array = this.DoTransitionDispatch(null, smuggledMethodCallMessage, out smuggledMethodReturnMessage);
}
else
{
array = this.DoTransitionDispatch(memoryStream.GetBuffer(), null, out smuggledMethodReturnMessage);
}
}
finally
{
CallContext.SetLogicalCallContext(logicalCallContext2);
}
if (smuggledMethodReturnMessage != null)
{
ArrayList deserializedArgs = smuggledMethodReturnMessage.FixupForNewAppDomain();
message2 = new MethodResponse((IMethodCallMessage)reqMsg, smuggledMethodReturnMessage, deserializedArgs);
}
else if (array != null)
{
MemoryStream stm = new MemoryStream(array);
message2 = CrossAppDomainSerializer.DeserializeMessage(stm, reqMsg as IMethodCallMessage);
}
}
catch (Exception e)
{
try
{
message2 = new ReturnMessage(e, reqMsg as IMethodCallMessage);
}
catch (Exception)
{
}
}
if (principal != null)
{
IMethodReturnMessage methodReturnMessage = message2 as IMethodReturnMessage;
if (methodReturnMessage != null)
{
LogicalCallContext logicalCallContext3 = methodReturnMessage.LogicalCallContext;
logicalCallContext3.Principal = principal;
}
}
return(message2);
}
public virtual IMessage SyncProcessMessage(IMessage reqMsg)
{
IMessage message = InternalSink.ValidateMessage(reqMsg);
if (message != null)
{
return(message);
}
IPrincipal principal = null;
IMessage message2 = null;
try
{
SmuggledMethodReturnMessage message5;
IMethodCallMessage message3 = reqMsg as IMethodCallMessage;
if (message3 != null)
{
LogicalCallContext logicalCallContext = message3.LogicalCallContext;
if (logicalCallContext != null)
{
principal = logicalCallContext.RemovePrincipalIfNotSerializable();
}
}
MemoryStream stream = null;
SmuggledMethodCallMessage smuggledMcm = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
if (smuggledMcm == null)
{
stream = CrossAppDomainSerializer.SerializeMessage(reqMsg);
}
LogicalCallContext callCtx = CallContext.SetLogicalCallContext(null);
MemoryStream stm = null;
byte[] buffer = null;
try
{
if (smuggledMcm != null)
{
buffer = this.DoTransitionDispatch(null, smuggledMcm, out message5);
}
else
{
buffer = this.DoTransitionDispatch(stream.GetBuffer(), null, out message5);
}
}
finally
{
CallContext.SetLogicalCallContext(callCtx);
}
if (message5 != null)
{
ArrayList deserializedArgs = message5.FixupForNewAppDomain();
message2 = new MethodResponse((IMethodCallMessage)reqMsg, message5, deserializedArgs);
}
else if (buffer != null)
{
stm = new MemoryStream(buffer);
message2 = CrossAppDomainSerializer.DeserializeMessage(stm, reqMsg as IMethodCallMessage);
}
}
catch (Exception exception)
{
try
{
message2 = new ReturnMessage(exception, reqMsg as IMethodCallMessage);
}
catch (Exception)
{
}
}
if (principal != null)
{
IMethodReturnMessage message6 = message2 as IMethodReturnMessage;
if (message6 != null)
{
message6.LogicalCallContext.Principal = principal;
}
}
return(message2);
}
[System.Security.SecurityCritical] // auto-generated
public virtual IMessage SyncProcessMessage(IMessage reqMsg)
{
Message.DebugOut("\n::::::::::::::::::::::::: CrossAppDomain Channel: [....] call starting");
IMessage errMsg = InternalSink.ValidateMessage(reqMsg);
if (errMsg != null)
{
return(errMsg);
}
// currentPrincipal is used to save the current principal. It should be
// restored on the reply message.
IPrincipal currentPrincipal = null;
IMessage desRetMsg = null;
try
{
IMethodCallMessage mcmReqMsg = reqMsg as IMethodCallMessage;
if (mcmReqMsg != null)
{
LogicalCallContext lcc = mcmReqMsg.LogicalCallContext;
if (lcc != null)
{
// Special case Principal since if might not be serializable
currentPrincipal = lcc.RemovePrincipalIfNotSerializable();
}
}
MemoryStream reqStm = null;
SmuggledMethodCallMessage smuggledMcm = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
if (smuggledMcm == null)
{
//*********************** SERIALIZE REQ-MSG ****************
// Deserialization of objects requires permissions that users
// of remoting are not guaranteed to possess. Since remoting
// can guarantee that it's users can't abuse deserialization
// (since it won't allow them to pass in raw blobs of
// serialized data), it should assert the permissions
// necessary before calling the deserialization code. This
// will terminate the security stackwalk caused when
// serialization checks for the correct permissions at the
// remoting stack frame so the check won't continue on to
// the user and fail. <EMAIL>[from [....]]</EMAIL>
// We will hold off from doing this for x-process channels
// until the big picture of distributed security is finalized.
reqStm = CrossAppDomainSerializer.SerializeMessage(reqMsg);
}
// Retrieve calling caller context here, where it is safe from the view
// of app domain checking code
LogicalCallContext oldCallCtx = CallContext.SetLogicalCallContext(null);
// Call helper method here, to avoid confusion with stack frames & app domains
MemoryStream retStm = null;
byte[] responseBytes = null;
SmuggledMethodReturnMessage smuggledMrm;
try
{
if (smuggledMcm != null)
{
responseBytes = DoTransitionDispatch(null, smuggledMcm, out smuggledMrm);
}
else
{
responseBytes = DoTransitionDispatch(reqStm.GetBuffer(), null, out smuggledMrm);
}
}
finally
{
CallContext.SetLogicalCallContext(oldCallCtx);
}
if (smuggledMrm != null)
{
ArrayList deserializedArgs = smuggledMrm.FixupForNewAppDomain();
desRetMsg = new MethodResponse((IMethodCallMessage)reqMsg,
smuggledMrm,
deserializedArgs);
}
else
{
if (responseBytes != null)
{
retStm = new MemoryStream(responseBytes);
Message.DebugOut("::::::::::::::::::::::::::: CrossAppDomain Channel: [....] call returning!!\n");
//*********************** DESERIALIZE RET-MSG **************
desRetMsg = CrossAppDomainSerializer.DeserializeMessage(retStm, reqMsg as IMethodCallMessage);
}
}
}
catch (Exception e)
{
Message.DebugOut("Arrgh.. XAppDomainSink::throwing exception " + e + "\n");
try
{
desRetMsg = new ReturnMessage(e, (reqMsg as IMethodCallMessage));
}
catch (Exception)
{
// Fatal Error .. can't do much here
}
}
// restore the principal if necessary.
if (currentPrincipal != null)
{
IMethodReturnMessage mrmRetMsg = desRetMsg as IMethodReturnMessage;
if (mrmRetMsg != null)
{
LogicalCallContext lcc = mrmRetMsg.LogicalCallContext;
lcc.Principal = currentPrincipal;
}
}
return(desRetMsg);
}
public virtual IMessage SyncProcessMessage(IMessage reqMsg)
{
IMessage message1 = InternalSink.ValidateMessage(reqMsg);
if (message1 != null)
{
return(message1);
}
IPrincipal principal = (IPrincipal)null;
IMessage message2 = (IMessage)null;
try
{
IMethodCallMessage methodCallMessage = reqMsg as IMethodCallMessage;
if (methodCallMessage != null)
{
LogicalCallContext logicalCallContext = methodCallMessage.LogicalCallContext;
if (logicalCallContext != null)
{
principal = logicalCallContext.RemovePrincipalIfNotSerializable();
}
}
MemoryStream memoryStream = (MemoryStream)null;
SmuggledMethodCallMessage smuggledMcm = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
if (smuggledMcm == null)
{
memoryStream = CrossAppDomainSerializer.SerializeMessage(reqMsg);
}
LogicalCallContext callCtx = CallContext.SetLogicalCallContext((LogicalCallContext)null);
byte[] buffer = (byte[])null;
SmuggledMethodReturnMessage smuggledMrm;
try
{
buffer = smuggledMcm == null?this.DoTransitionDispatch(memoryStream.GetBuffer(), (SmuggledMethodCallMessage)null, out smuggledMrm) : this.DoTransitionDispatch((byte[])null, smuggledMcm, out smuggledMrm);
}
finally
{
CallContext.SetLogicalCallContext(callCtx);
}
if (smuggledMrm != null)
{
ArrayList deserializedArgs = smuggledMrm.FixupForNewAppDomain();
message2 = (IMessage) new MethodResponse((IMethodCallMessage)reqMsg, smuggledMrm, deserializedArgs);
}
else if (buffer != null)
{
message2 = CrossAppDomainSerializer.DeserializeMessage(new MemoryStream(buffer), reqMsg as IMethodCallMessage);
}
}
catch (Exception ex1)
{
try
{
message2 = (IMessage) new ReturnMessage(ex1, reqMsg as IMethodCallMessage);
}
catch (Exception ex2)
{
}
}
if (principal != null)
{
IMethodReturnMessage methodReturnMessage = message2 as IMethodReturnMessage;
if (methodReturnMessage != null)
{
methodReturnMessage.LogicalCallContext.Principal = principal;
}
}
return(message2);
}