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