public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("---------------------------Envoy Chain Terminator: AsyncProcessMessage"); IMessageCtrl msgCtrl = null; IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { // Notify replySink of error if we can if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { msgCtrl = Thread.CurrentContext.GetClientContextChain().AsyncProcessMessage(reqMsg, replySink); } return(msgCtrl); }
[System.Security.SecurityCritical] // auto-generated internal static ServerIdentity GetServerIdentity(IMessage reqMsg) { ServerIdentity srvID = null; bool bOurMsg = false; String objURI = null; IInternalMessage iim = reqMsg as IInternalMessage; if (iim != null) { Message.DebugOut("GetServerIdentity.ServerIdentity from IInternalMessage\n"); srvID = ((IInternalMessage)reqMsg).ServerIdentityObject; bOurMsg = true; } else if (reqMsg is InternalMessageWrapper) { srvID = (ServerIdentity)((InternalMessageWrapper)reqMsg).GetServerIdentityObject(); } // Try the slow path if the identity has not been obtained yet if (null == srvID) { Message.DebugOut("GetServerIdentity.ServerIdentity from IMethodCallMessage\n"); objURI = GetURI(reqMsg); Identity id = IdentityHolder.ResolveIdentity(objURI); if (id is ServerIdentity) { srvID = (ServerIdentity)id; // Cache the serverIdentity in the message if (bOurMsg) { iim.ServerIdentityObject = srvID; } } } return(srvID); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("---------------------------Envoy Chain Terminator: AsyncProcessMessage"); IMessageCtrl msgCtrl = null; IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { // Notify replySink of error if we can // FUTURE: is it okay to reply right away before we return // the IMessageCtrl for the original call? if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { msgCtrl = Thread.CurrentContext.GetClientContextChain().AsyncProcessMessage(reqMsg, replySink); } return(msgCtrl); }
[System.Security.SecurityCritical] // auto-generated_required public virtual ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector ssout) { if (type == null) { throw new ArgumentNullException("type"); } Contract.EndContractBlock(); Message.DebugOut("Entered GetSurrogate for " + type.FullName + "\n"); if (type.IsMarshalByRef) { Message.DebugOut("Selected surrogate for " + type.FullName); ssout = this; return(_remotingSurrogate); } else if (s_IMethodCallMessageType.IsAssignableFrom(type) || s_IMethodReturnMessageType.IsAssignableFrom(type)) { ssout = this; return(_messageSurrogate); } else if (s_ObjRefType.IsAssignableFrom(type)) { ssout = this; return(_objRefSurrogate); } else if (_next != null) { return(_next.GetSurrogate(type, context, out ssout)); } else { ssout = null; return(null); } } // GetSurrogate
public virtual void GetObjectData(Object obj, SerializationInfo info, StreamingContext context) { if (obj == null) { throw new ArgumentNullException("obj"); } if (info == null) { throw new ArgumentNullException("info"); } bool returnMessage = false; bool constructionMessage = false; IMethodMessage msg = obj as IMethodMessage; if (null != msg) { IDictionaryEnumerator de = msg.Properties.GetEnumerator(); if (msg is IMethodCallMessage) { if (obj is IConstructionCallMessage) { constructionMessage = true; } info.SetType(constructionMessage ? _constructionCallType : _methodCallType); } else { IMethodReturnMessage mrm = msg as IMethodReturnMessage; if (null != mrm) { returnMessage = true; info.SetType((obj is IConstructionReturnMessage) ? _constructionResponseType : _methodResponseType); if (((IMethodReturnMessage)msg).Exception != null) { info.AddValue("__fault", ((IMethodReturnMessage)msg).Exception, _exceptionType); } } else { throw new RemotingException(Environment.GetResourceString("Remoting_InvalidMsg")); } } while (de.MoveNext()) { if ((obj == _ss.GetRootObject()) && (_ss.Filter != null) && _ss.Filter((String)de.Key, de.Value)) { continue; } if (de.Value != null) { String key = de.Key.ToString(); if (key.Equals("__CallContext")) { // If the CallContext has only the call Id, then there is no need to put the entire // LogicalCallContext type on the wire LogicalCallContext lcc = (LogicalCallContext)de.Value; if (lcc.HasInfo) { info.AddValue(key, lcc); } else { info.AddValue(key, lcc.RemotingData.LogicalCallID); } } else if (key.Equals("__MethodSignature")) { // If the method is not overloaded, the method signature does not need to go on the wire // note - IsMethodOverloaded does not work well with constructors if (constructionMessage || RemotingServices.IsMethodOverloaded(msg)) { info.AddValue(key, de.Value); continue; } Message.DebugOut("MessageSurrogate::GetObjectData. Method not overloaded, so no MethodSignature \n"); } else { returnMessage = returnMessage; info.AddValue(key, de.Value); } } else { info.AddValue(de.Key.ToString(), de.Value, _objectType); } } } else { throw new RemotingException(Environment.GetResourceString("Remoting_InvalidMsg")); } }
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); }
[System.Security.SecurityCritical] // auto-generated public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: AsyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); IMessageCtrl msgCtrl = null; if (errMsg == null) { errMsg = DisallowAsyncActivation(reqMsg); } if (errMsg != null) { if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { // If active, notify the profiler that an asynchronous remoting call is being made. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g; RemotingServices.CORProfilerRemotingClientSendingMessage(out g, true); if (RemotingServices.CORProfilerTrackRemotingCookie()) { reqMsg.Properties["CORProfilerCookie"] = g; } // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is received. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ClientAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context cliCtx = Thread.CurrentContext; // Notify dynamic sinks that an Async call started cliCtx.NotifyDynamicSinks( reqMsg, true, // bCliSide true, // bStart true, // bAsync true); // bNotifyGlobals // Intercept the async reply to force the thread back // into the client-context before it executes further // and to notify dynamic sinks if (replySink != null) { replySink = new AsyncReplySink(replySink, cliCtx); } Object[] args = new Object[] { null, null, null }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(AsyncProcessMessageCallback); IMessageSink channelSink = GetChannelSink(reqMsg); // Forward call to the channel. args[0] = reqMsg; args[1] = replySink; args[2] = channelSink; // Move to default context unless we are going through // the cross-context channel if (channelSink != CrossContextChannel.MessageSink) { msgCtrl = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, xctxDel, args); } else { msgCtrl = (IMessageCtrl)xctxDel(args); } } return(msgCtrl); }
[System.Security.SecurityCritical] // auto-generated public virtual IMessage SyncProcessMessage(IMessage reqMsg) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: SyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { return(errMsg); } Context ctx = Thread.CurrentContext; bool bHasDynamicSinks = ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide true, // bStart false, // bAsync true); // bNotifyGlobals IMessage replyMsg; if (reqMsg is IConstructionCallMessage) { errMsg = ctx.NotifyActivatorProperties( reqMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } replyMsg = ((IConstructionCallMessage)reqMsg).Activator.Activate( (IConstructionCallMessage)reqMsg); BCLDebug.Assert(replyMsg is IConstructionReturnMessage, "bad ctorRetMsg"); errMsg = ctx.NotifyActivatorProperties( replyMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } } else { replyMsg = null; ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend); Object[] args = new Object[] { null, null }; IMessageSink channelSink = GetChannelSink(reqMsg); // Forward call to the channel. args[0] = reqMsg; args[1] = channelSink; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); // Move to default context unless we are going through // the cross-context channel if (channelSink != CrossContextChannel.MessageSink) { replyMsg = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, xctxDel, args); } else { replyMsg = (IMessage)xctxDel(args); } ChannelServices.NotifyProfiler(replyMsg, RemotingProfilerEvent.ClientReceive); } if (bHasDynamicSinks) { ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide false, // bStart false, // bAsync true); // bNotifyGlobals } return(replyMsg); }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: SyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { return(errMsg); } Context ctx = Thread.CurrentContext; bool bHasDynamicSinks = ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide true, // bStart false, // bAsync true); // bNotifyGlobals IMessage replyMsg; if (reqMsg is IConstructionCallMessage) { errMsg = ctx.NotifyActivatorProperties( reqMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } replyMsg = ((IConstructionCallMessage)reqMsg).Activator.Activate( (IConstructionCallMessage)reqMsg); BCLDebug.Assert(replyMsg is IConstructionReturnMessage, "bad ctorRetMsg"); errMsg = ctx.NotifyActivatorProperties( replyMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } } else { ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend); // Forward call to the channel. IMessageSink channelSink = GetChannelSink(reqMsg); // Move to default context unless we are going through // the cross-context channel ContextTransitionFrame frame = new ContextTransitionFrame(); if (channelSink != CrossContextChannel.MessageSink) { Thread.CurrentThread.EnterContext( Context.DefaultContext, ref frame); } replyMsg = channelSink.SyncProcessMessage(reqMsg); if (channelSink != CrossContextChannel.MessageSink) { Thread.CurrentThread.ReturnToContext(ref frame); } ChannelServices.NotifyProfiler(replyMsg, RemotingProfilerEvent.ClientReceive); } if (bHasDynamicSinks) { ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide false, // bStart false, // bAsync true); // bNotifyGlobals } return(replyMsg); }
[System.Security.SecurityCritical] // auto-generated_required public virtual void GetObjectData(Object obj, SerializationInfo info, StreamingContext context) { if (obj == null) { throw new ArgumentNullException("obj"); } if (info == null) { throw new ArgumentNullException("info"); } Contract.EndContractBlock(); bool returnMessage = false; bool constructionMessage = false; IMethodMessage msg = obj as IMethodMessage; if (null != msg) { IDictionaryEnumerator de = msg.Properties.GetEnumerator(); if (msg is IMethodCallMessage) { if (obj is IConstructionCallMessage) { constructionMessage = true; } info.SetType(constructionMessage ? _constructionCallType : _methodCallType); } else { IMethodReturnMessage mrm = msg as IMethodReturnMessage; if (null != mrm) { returnMessage = true; info.SetType((obj is IConstructionReturnMessage) ? _constructionResponseType : _methodResponseType); if (((IMethodReturnMessage)msg).Exception != null) { info.AddValue("__fault", ((IMethodReturnMessage)msg).Exception, _exceptionType); } } else { throw new RemotingException(Environment.GetResourceString("Remoting_InvalidMsg")); } } while (de.MoveNext()) { if ((obj == _ss.GetRootObject()) && (_ss.Filter != null) && _ss.Filter((String)de.Key, de.Value)) { continue; } if (de.Value != null) { String key = de.Key.ToString(); if (key.Equals("__CallContext")) { // If the CallContext has only the call Id, then there is no need to put the entire // LogicalCallContext type on the wire LogicalCallContext lcc = (LogicalCallContext)de.Value; if (lcc.HasInfo) { info.AddValue(key, lcc); } else { info.AddValue(key, lcc.RemotingData.LogicalCallID); } } else if (key.Equals("__MethodSignature")) { // If the method is not overloaded, the method signature does not need to go on the wire // note - IsMethodOverloaded does not work well with constructors if (constructionMessage || RemotingServices.IsMethodOverloaded(msg)) { info.AddValue(key, de.Value); continue; } Message.DebugOut("MessageSurrogate::GetObjectData. Method not overloaded, so no MethodSignature \n"); } else { #if false /* If the streaming context says this is a x-domain call, then there is no * need to include the following fields in the return message. Right now I am not sure * how to identify a cross-domain streaming context - Ashok */ if (returnMessage && (key.Equals("__Uri") || key.Equals("__MethodName") || key.Equals("__TypeName"))) { continue; } else #endif #pragma warning disable 1717 // assignment to self returnMessage = returnMessage; #pragma warning restore 1717 info.AddValue(key, de.Value); } } else { info.AddValue(de.Key.ToString(), de.Value, _objectType); } } } else { throw new RemotingException(Environment.GetResourceString("Remoting_InvalidMsg")); } }