[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
Пример #2
0
        internal void FreeNamedDataSlot(string name)
        {
            if (_lcc != null)
            {
                _lcc.FreeNamedDataSlot(name);
            }

            if (local_data != null)
            {
                local_data.Remove(name);
            }
        }
Пример #3
0
        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());
        }
Пример #4
0
        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());
        }