ValidateMessage() статический приватный Метод

static private ValidateMessage ( IMessage reqMsg ) : IMessage
reqMsg IMessage
Результат IMessage
Пример #1
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl messageCtrl = (IMessageCtrl)null;
            IMessage     msg1        = InternalSink.ValidateMessage(reqMsg) ?? InternalSink.DisallowAsyncActivation(reqMsg);

            if (msg1 != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(msg1);
                }
            }
            else
            {
                MarshalByRefObject marshalByRefObject;
                IMessageSink       objectChain = this.GetObjectChain(reqMsg, out marshalByRefObject);
                IDisposable        iDis;
                if (marshalByRefObject != null && (iDis = marshalByRefObject as IDisposable) != null)
                {
                    replySink = (IMessageSink) new DisposeSink(iDis, replySink);
                }
                IMessage     msg2       = reqMsg;
                IMessageSink replySink1 = replySink;
                messageCtrl = objectChain.AsyncProcessMessage(msg2, replySink1);
            }
            return(messageCtrl);
        }
Пример #2
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl result  = null;
            IMessage     message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(message);
                }
            }
            else
            {
                IMessageSink messageSink = this._stackBuilderSink.ServerObject as IMessageSink;
                if (messageSink != null)
                {
                    result = messageSink.AsyncProcessMessage(reqMsg, replySink);
                }
                else
                {
                    result = this._stackBuilderSink.AsyncProcessMessage(reqMsg, replySink);
                }
            }
            return(result);
        }
Пример #3
0
        public virtual IMessage SyncProcessMessage(IMessage reqMsg)
        {
            IMessage message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                return(message);
            }
            ServerIdentity serverIdentity         = InternalSink.GetServerIdentity(reqMsg);
            ArrayWithSize  serverSideDynamicSinks = serverIdentity.ServerSideDynamicSinks;

            if (serverSideDynamicSinks != null)
            {
                DynamicPropertyHolder.NotifyDynamicSinks(reqMsg, serverSideDynamicSinks, false, true, false);
            }
            IMessageSink messageSink = this._stackBuilderSink.ServerObject as IMessageSink;
            IMessage     message2;

            if (messageSink != null)
            {
                message2 = messageSink.SyncProcessMessage(reqMsg);
            }
            else
            {
                message2 = this._stackBuilderSink.SyncProcessMessage(reqMsg);
            }
            if (serverSideDynamicSinks != null)
            {
                DynamicPropertyHolder.NotifyDynamicSinks(message2, serverSideDynamicSinks, false, false, false);
            }
            return(message2);
        }
Пример #4
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl result  = null;
            IMessage     message = InternalSink.ValidateMessage(reqMsg);

            if (message == null)
            {
                message = InternalSink.DisallowAsyncActivation(reqMsg);
            }
            if (message != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(message);
                }
            }
            else
            {
                MarshalByRefObject marshalByRefObject;
                IMessageSink       objectChain = this.GetObjectChain(reqMsg, out marshalByRefObject);
                IDisposable        iDis;
                if (marshalByRefObject != null && (iDis = (marshalByRefObject as IDisposable)) != null)
                {
                    DisposeSink disposeSink = new DisposeSink(iDis, replySink);
                    replySink = disposeSink;
                }
                result = objectChain.AsyncProcessMessage(reqMsg, replySink);
            }
            return(result);
        }
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl       ctrl = null;
            MarshalByRefObject obj2;
            IDisposable        disposable;
            IMessage           msg = InternalSink.ValidateMessage(reqMsg);

            if (msg == null)
            {
                msg = InternalSink.DisallowAsyncActivation(reqMsg);
            }
            if (msg != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(msg);
                }
                return(ctrl);
            }
            IMessageSink objectChain = this.GetObjectChain(reqMsg, out obj2);

            if ((obj2 != null) && ((disposable = obj2 as IDisposable) != null))
            {
                DisposeSink sink2 = new DisposeSink(disposable, replySink);
                replySink = sink2;
            }
            return(objectChain.AsyncProcessMessage(reqMsg, replySink));
        }
Пример #6
0
        public virtual IMessage SyncProcessMessage(IMessage reqMsg)
        {
            IMessage message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                return(message);
            }
            return(Thread.CurrentContext.GetClientContextChain().SyncProcessMessage(reqMsg));
        }
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessage     message = InternalSink.ValidateMessage(reqMsg);
            IMessageCtrl result  = null;

            if (message == null)
            {
                message = InternalSink.DisallowAsyncActivation(reqMsg);
            }
            if (message != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(message);
                }
            }
            else
            {
                if (RemotingServices.CORProfilerTrackRemotingAsync())
                {
                    Guid guid;
                    RemotingServices.CORProfilerRemotingClientSendingMessage(out guid, true);
                    if (RemotingServices.CORProfilerTrackRemotingCookie())
                    {
                        reqMsg.Properties["CORProfilerCookie"] = guid;
                    }
                    if (replySink != null)
                    {
                        IMessageSink messageSink = new ClientAsyncReplyTerminatorSink(replySink);
                        replySink = messageSink;
                    }
                }
                Context currentContext = Thread.CurrentContext;
                currentContext.NotifyDynamicSinks(reqMsg, true, true, true, true);
                if (replySink != null)
                {
                    replySink = new AsyncReplySink(replySink, currentContext);
                }
                object[] array = new object[3];
                InternalCrossContextDelegate internalCrossContextDelegate = new InternalCrossContextDelegate(ClientContextTerminatorSink.AsyncProcessMessageCallback);
                IMessageSink channelSink = this.GetChannelSink(reqMsg);
                array[0] = reqMsg;
                array[1] = replySink;
                array[2] = channelSink;
                if (channelSink != CrossContextChannel.MessageSink)
                {
                    result = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, internalCrossContextDelegate, array);
                }
                else
                {
                    result = (IMessageCtrl)internalCrossContextDelegate(array);
                }
            }
            return(result);
        }
        public virtual IMessage SyncProcessMessage(IMessage reqMsg)
        {
            IMessage message2;
            IMessage message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                return(message);
            }
            Context currentContext = Thread.CurrentContext;
            bool    flag           = currentContext.NotifyDynamicSinks(reqMsg, true, true, false, true);

            if (reqMsg is IConstructionCallMessage)
            {
                message = currentContext.NotifyActivatorProperties(reqMsg, false);
                if (message != null)
                {
                    return(message);
                }
                message2 = ((IConstructionCallMessage)reqMsg).Activator.Activate((IConstructionCallMessage)reqMsg);
                message  = currentContext.NotifyActivatorProperties(message2, false);
                if (message != null)
                {
                    return(message);
                }
            }
            else
            {
                message2 = null;
                ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend);
                object[]     args        = new object[2];
                IMessageSink channelSink = this.GetChannelSink(reqMsg);
                args[0] = reqMsg;
                args[1] = channelSink;
                InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ClientContextTerminatorSink.SyncProcessMessageCallback);
                if (channelSink != CrossContextChannel.MessageSink)
                {
                    message2 = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, ftnToCall, args);
                }
                else
                {
                    message2 = (IMessage)ftnToCall(args);
                }
                ChannelServices.NotifyProfiler(message2, RemotingProfilerEvent.ClientReceive);
            }
            if (flag)
            {
                currentContext.NotifyDynamicSinks(reqMsg, true, false, false, true);
            }
            return(message2);
        }
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessage     msg  = InternalSink.ValidateMessage(reqMsg);
            IMessageCtrl ctrl = null;

            if (msg == null)
            {
                msg = InternalSink.DisallowAsyncActivation(reqMsg);
            }
            if (msg != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(msg);
                }
                return(ctrl);
            }
            if (RemotingServices.CORProfilerTrackRemotingAsync())
            {
                Guid guid;
                RemotingServices.CORProfilerRemotingClientSendingMessage(out guid, true);
                if (RemotingServices.CORProfilerTrackRemotingCookie())
                {
                    reqMsg.Properties["CORProfilerCookie"] = guid;
                }
                if (replySink != null)
                {
                    IMessageSink sink = new ClientAsyncReplyTerminatorSink(replySink);
                    replySink = sink;
                }
            }
            Context currentContext = Thread.CurrentContext;

            currentContext.NotifyDynamicSinks(reqMsg, true, true, true, true);
            if (replySink != null)
            {
                replySink = new System.Runtime.Remoting.Messaging.AsyncReplySink(replySink, currentContext);
            }
            object[] args = new object[3];
            InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ClientContextTerminatorSink.AsyncProcessMessageCallback);
            IMessageSink channelSink = this.GetChannelSink(reqMsg);

            args[0] = reqMsg;
            args[1] = replySink;
            args[2] = channelSink;
            if (channelSink != CrossContextChannel.MessageSink)
            {
                return((IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, ftnToCall, args));
            }
            return((IMessageCtrl)ftnToCall(args));
        }
Пример #10
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl ctrl = null;
            IMessage     msg  = InternalSink.ValidateMessage(reqMsg);

            if (msg != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(msg);
                }
                return(ctrl);
            }
            return(Thread.CurrentContext.GetClientContextChain().AsyncProcessMessage(reqMsg, replySink));
        }
Пример #11
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl result  = null;
            IMessage     message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(message);
                }
            }
            else
            {
                result = Thread.CurrentContext.GetClientContextChain().AsyncProcessMessage(reqMsg, replySink);
            }
            return(result);
        }
Пример #12
0
        public virtual IMessage SyncProcessMessage(IMessage reqMsg)
        {
            IMessage message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                return(message);
            }
            Context  currentContext = Thread.CurrentContext;
            IMessage message2;

            if (reqMsg is IConstructionCallMessage)
            {
                message = currentContext.NotifyActivatorProperties(reqMsg, true);
                if (message != null)
                {
                    return(message);
                }
                message2 = ((IConstructionCallMessage)reqMsg).Activator.Activate((IConstructionCallMessage)reqMsg);
                message  = currentContext.NotifyActivatorProperties(message2, true);
                if (message != null)
                {
                    return(message);
                }
            }
            else
            {
                MarshalByRefObject marshalByRefObject = null;
                try
                {
                    message2 = this.GetObjectChain(reqMsg, out marshalByRefObject).SyncProcessMessage(reqMsg);
                }
                finally
                {
                    IDisposable disposable;
                    if (marshalByRefObject != null && (disposable = (marshalByRefObject as IDisposable)) != null)
                    {
                        disposable.Dispose();
                    }
                }
            }
            return(message2);
        }
Пример #13
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl messageCtrl = (IMessageCtrl)null;
            IMessage     msg         = InternalSink.ValidateMessage(reqMsg);

            if (msg != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(msg);
                }
            }
            else
            {
                IMessageSink messageSink = this._stackBuilderSink.ServerObject as IMessageSink;
                messageCtrl = messageSink == null?this._stackBuilderSink.AsyncProcessMessage(reqMsg, replySink) : messageSink.AsyncProcessMessage(reqMsg, replySink);
            }
            return(messageCtrl);
        }
Пример #14
0
        public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
        {
            IMessageCtrl ctrl = null;
            IMessage     msg  = InternalSink.ValidateMessage(reqMsg);

            if (msg != null)
            {
                if (replySink != null)
                {
                    replySink.SyncProcessMessage(msg);
                }
                return(ctrl);
            }
            IMessageSink serverObject = this._stackBuilderSink.ServerObject as IMessageSink;

            if (serverObject != null)
            {
                return(serverObject.AsyncProcessMessage(reqMsg, replySink));
            }
            return(this._stackBuilderSink.AsyncProcessMessage(reqMsg, replySink));
        }
Пример #15
0
        public virtual IMessage SyncProcessMessage(IMessage reqMsg)
        {
            IMessage message = InternalSink.ValidateMessage(reqMsg);

            if (message != null)
            {
                return(message);
            }
            ArrayWithSize sideDynamicSinks = InternalSink.GetServerIdentity(reqMsg).ServerSideDynamicSinks;

            if (sideDynamicSinks != null)
            {
                DynamicPropertyHolder.NotifyDynamicSinks(reqMsg, sideDynamicSinks, false, true, false);
            }
            IMessageSink messageSink = this._stackBuilderSink.ServerObject as IMessageSink;
            IMessage     msg         = messageSink == null?this._stackBuilderSink.SyncProcessMessage(reqMsg) : messageSink.SyncProcessMessage(reqMsg);

            if (sideDynamicSinks != null)
            {
                DynamicPropertyHolder.NotifyDynamicSinks(msg, sideDynamicSinks, false, false, false);
            }
            return(msg);
        }
Пример #16
0
        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);
        }
Пример #17
0
        public virtual IMessage SyncProcessMessage(IMessage msg)
        {
            IMessage message = InternalSink.ValidateMessage(msg);

            if (message != null)
            {
                return(message);
            }
            IMethodCallMessage methodCallMessage   = msg as IMethodCallMessage;
            LogicalCallContext logicalCallContext1 = (LogicalCallContext)null;
            object             data = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.GetData("__xADCall");
            bool     flag           = false;
            IMessage msg1;

            try
            {
                object obj = this._server;
                StackBuilderSink.VerifyIsOkToCallMethod(obj, (IMethodMessage)methodCallMessage);
                LogicalCallContext logicalCallContext2 = methodCallMessage == null ? (LogicalCallContext)msg.Properties[(object)"__CallContext"] : methodCallMessage.LogicalCallContext;
                logicalCallContext1 = CallContext.SetLogicalCallContext(logicalCallContext2);
                flag = true;
                logicalCallContext2.PropagateIncomingHeadersToCallContext(msg);
                StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext2, logicalCallContext1);
                if (this.IsOKToStackBlt((IMethodMessage)methodCallMessage, obj) && ((Message)methodCallMessage).Dispatch(obj))
                {
                    msg1 = (IMessage) new StackBasedReturnMessage();
                    ((StackBasedReturnMessage)msg1).InitFields((Message)methodCallMessage);
                    LogicalCallContext logicalCallContext3 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
                    logicalCallContext3.PropagateOutgoingHeadersToMessage(msg1);
                    ((StackBasedReturnMessage)msg1).SetLogicalCallContext(logicalCallContext3);
                }
                else
                {
                    MethodBase methodBase = StackBuilderSink.GetMethodBase((IMethodMessage)methodCallMessage);
                    object[]   outArgs1   = (object[])null;
                    RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
                    object[] args = Message.CoerceArgs((IMethodMessage)methodCallMessage, reflectionCachedData.Parameters);
                    object   ret  = this.PrivateProcessMessage(methodBase.MethodHandle, args, obj, out outArgs1);
                    this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs1);
                    LogicalCallContext logicalCallContext3 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
                    if (data != null && (bool)data && logicalCallContext3 != null)
                    {
                        logicalCallContext3.RemovePrincipalIfNotSerializable();
                    }
                    object[]           outArgs2     = outArgs1;
                    int                outArgsCount = outArgs2 == null ? 0 : outArgs1.Length;
                    LogicalCallContext callCtx      = logicalCallContext3;
                    IMethodCallMessage mcm          = methodCallMessage;
                    msg1 = (IMessage) new ReturnMessage(ret, outArgs2, outArgsCount, callCtx, mcm);
                    logicalCallContext3.PropagateOutgoingHeadersToMessage(msg1);
                    CallContext.SetLogicalCallContext(logicalCallContext1);
                }
            }
            catch (Exception ex)
            {
                IMethodCallMessage mcm = methodCallMessage;
                msg1 = (IMessage) new ReturnMessage(ex, mcm);
                ((ReturnMessage)msg1).SetLogicalCallContext(methodCallMessage.LogicalCallContext);
                if (flag)
                {
                    CallContext.SetLogicalCallContext(logicalCallContext1);
                }
            }
            return(msg1);
        }
Пример #18
0
 public virtual IMessage SyncProcessMessage(IMessage reqMsg)
 {
     return(InternalSink.ValidateMessage(reqMsg) ?? Thread.CurrentContext.GetClientContextChain().SyncProcessMessage(reqMsg));
 }
        public virtual IMessage SyncProcessMessage(IMessage msg)
        {
            IMessage message = InternalSink.ValidateMessage(msg);

            if (message != null)
            {
                return(message);
            }
            IMethodCallMessage methodCallMessage   = msg as IMethodCallMessage;
            LogicalCallContext logicalCallContext  = null;
            LogicalCallContext logicalCallContext2 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
            object             data = logicalCallContext2.GetData("__xADCall");
            bool     flag           = false;
            IMessage message2;

            try
            {
                object server = this._server;
                StackBuilderSink.VerifyIsOkToCallMethod(server, methodCallMessage);
                LogicalCallContext logicalCallContext3;
                if (methodCallMessage != null)
                {
                    logicalCallContext3 = methodCallMessage.LogicalCallContext;
                }
                else
                {
                    logicalCallContext3 = (LogicalCallContext)msg.Properties["__CallContext"];
                }
                logicalCallContext = CallContext.SetLogicalCallContext(logicalCallContext3);
                flag = true;
                logicalCallContext3.PropagateIncomingHeadersToCallContext(msg);
                StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext3, logicalCallContext);
                if (this.IsOKToStackBlt(methodCallMessage, server) && ((Message)methodCallMessage).Dispatch(server))
                {
                    message2 = new StackBasedReturnMessage();
                    ((StackBasedReturnMessage)message2).InitFields((Message)methodCallMessage);
                    LogicalCallContext logicalCallContext4 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
                    logicalCallContext4.PropagateOutgoingHeadersToMessage(message2);
                    ((StackBasedReturnMessage)message2).SetLogicalCallContext(logicalCallContext4);
                }
                else
                {
                    MethodBase methodBase = StackBuilderSink.GetMethodBase(methodCallMessage);
                    object[]   array      = null;
                    RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
                    object[] args = Message.CoerceArgs(methodCallMessage, reflectionCachedData.Parameters);
                    object   ret  = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, out array);
                    this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref array);
                    LogicalCallContext logicalCallContext5 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
                    if (data != null && (bool)data && logicalCallContext5 != null)
                    {
                        logicalCallContext5.RemovePrincipalIfNotSerializable();
                    }
                    message2 = new ReturnMessage(ret, array, (array == null) ? 0 : array.Length, logicalCallContext5, methodCallMessage);
                    logicalCallContext5.PropagateOutgoingHeadersToMessage(message2);
                    CallContext.SetLogicalCallContext(logicalCallContext);
                }
            }
            catch (Exception e)
            {
                message2 = new ReturnMessage(e, methodCallMessage);
                ((ReturnMessage)message2).SetLogicalCallContext(methodCallMessage.LogicalCallContext);
                if (flag)
                {
                    CallContext.SetLogicalCallContext(logicalCallContext);
                }
            }
            return(message2);
        }
        internal virtual IMessage SyncProcessMessage(IMessage msg, int methodPtr, bool fExecuteInContext)
        {
            IMessage message3;
            IMessage message = InternalSink.ValidateMessage(msg);

            if (message != null)
            {
                return(message);
            }
            IMethodCallMessage message2          = msg as IMethodCallMessage;
            LogicalCallContext threadCallContext = null;
            object             obj2 = CallContext.GetLogicalCallContext().GetData("__xADCall");
            bool flag = false;

            try
            {
                object server = this._server;
                VerifyIsOkToCallMethod(server, message2);
                LogicalCallContext callCtx = null;
                if (message2 != null)
                {
                    callCtx = message2.LogicalCallContext;
                }
                else
                {
                    callCtx = (LogicalCallContext)msg.Properties["__CallContext"];
                }
                threadCallContext = CallContext.SetLogicalCallContext(callCtx);
                flag = true;
                callCtx.PropagateIncomingHeadersToCallContext(msg);
                PreserveThreadPrincipalIfNecessary(callCtx, threadCallContext);
                if (this.IsOKToStackBlt(message2, server) && ((Message)message2).Dispatch(server, fExecuteInContext))
                {
                    message3 = new StackBasedReturnMessage();
                    ((StackBasedReturnMessage)message3).InitFields((Message)message2);
                    LogicalCallContext context4 = CallContext.GetLogicalCallContext();
                    context4.PropagateOutgoingHeadersToMessage(message3);
                    ((StackBasedReturnMessage)message3).SetLogicalCallContext(context4);
                    return(message3);
                }
                MethodBase methodBase = GetMethodBase(message2);
                object[]   outArgs    = null;
                object     ret        = null;
                RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
                object[] args = Message.CoerceArgs(message2, reflectionCachedData.Parameters);
                ret = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, methodPtr, fExecuteInContext, out outArgs);
                this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs);
                LogicalCallContext logicalCallContext = CallContext.GetLogicalCallContext();
                if (((obj2 != null) && ((bool)obj2)) && (logicalCallContext != null))
                {
                    logicalCallContext.RemovePrincipalIfNotSerializable();
                }
                message3 = new ReturnMessage(ret, outArgs, (outArgs == null) ? 0 : outArgs.Length, logicalCallContext, message2);
                logicalCallContext.PropagateOutgoingHeadersToMessage(message3);
                CallContext.SetLogicalCallContext(threadCallContext);
            }
            catch (Exception exception)
            {
                message3 = new ReturnMessage(exception, message2);
                ((ReturnMessage)message3).SetLogicalCallContext(message2.LogicalCallContext);
                if (flag)
                {
                    CallContext.SetLogicalCallContext(threadCallContext);
                }
            }
            return(message3);
        }