public static SyncDispatchMessage ( IMessage msg ) : IMessage | ||
msg | IMessage | |
return | IMessage |
[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
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
/// <summary>Dispatches incoming remote calls.</summary> /// <returns>A <see cref="T:System.Runtime.Remoting.Channels.ServerProcessing" /> that gives the status of the server message processing.</returns> /// <param name="sinkStack">The stack of server channel sinks that the message already traversed. </param> /// <param name="msg">The message to dispatch. </param> /// <param name="replyMsg">When this method returns, contains a <see cref="T:System.Runtime.Remoting.Messaging.IMessage" /> that holds the reply from the server to the message that is contained in the <paramref name="msg" /> parameter. This parameter is passed uninitialized. </param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="msg" /> parameter is null. </exception> /// <exception cref="T:System.Security.SecurityException">The immediate caller does not have infrastructure permission. </exception> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure" /> /// </PermissionSet> public static ServerProcessing DispatchMessage(IServerChannelSinkStack sinkStack, IMessage msg, out IMessage replyMsg) { if (msg == null) { throw new ArgumentNullException("msg"); } replyMsg = ChannelServices.SyncDispatchMessage(msg); if (RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase)) { return(ServerProcessing.OneWay); } return(ServerProcessing.Complete); }
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 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()); }