public static IConstructionReturnMessage CreateConstructionReturnMessage(IConstructionCallMessage ctorMsg, MarshalByRefObject retObj)
        {
            IConstructionReturnMessage ctorRetMsg = null;

            // Create the return message
            ctorRetMsg = new ConstructorReturnMessage(retObj, null, 0, null, ctorMsg);

            // NOTE: WE ALLOW ONLY DEFAULT CTORs on SERVICEDCOMPONENTS

            return(ctorRetMsg);
        }
Exemple #2
0
        internal static IConstructionReturnMessage SetupConstructionReply(object serverObj, IConstructionCallMessage ctorMsg, Exception e)
        {
            IConstructionReturnMessage message = null;

            if (e == null)
            {
                return(new ConstructorReturnMessage((MarshalByRefObject)serverObj, null, 0, (LogicalCallContext)ctorMsg.Properties[Message.CallContextKey], ctorMsg));
            }
            message = new ConstructorReturnMessage(e, null);
            ((ConstructorReturnMessage)message).SetLogicalCallContext((LogicalCallContext)ctorMsg.Properties[Message.CallContextKey]);
            return(message);
        }
        public IConstructionReturnMessage InitializeServerObject(IConstructionCallMessage ctorMsg)
        {
            IConstructionReturnMessage message = null;

            if (this._serverObject != null)
            {
                return(message);
            }
            Type proxiedType = this.GetProxiedType();

            if ((ctorMsg != null) && (ctorMsg.ActivationType != proxiedType))
            {
                throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Proxy_BadTypeForActivation"), new object[] { proxiedType.FullName, ctorMsg.ActivationType }));
            }
            this._serverObject = RemotingServices.AllocateUninitializedObject(proxiedType);
            this.SetContextForDefaultStub();
            MarshalByRefObject   transparentProxy = (MarshalByRefObject)this.GetTransparentProxy();
            IMethodReturnMessage message2         = null;
            Exception            e = null;

            if (ctorMsg != null)
            {
                message2 = RemotingServices.ExecuteMessage(transparentProxy, ctorMsg);
                e        = message2.Exception;
            }
            else
            {
                try
                {
                    RemotingServices.CallDefaultCtor(transparentProxy);
                }
                catch (Exception exception2)
                {
                    e = exception2;
                }
            }
            if (e == null)
            {
                object[]           outArgs      = (message2 == null) ? null : message2.OutArgs;
                int                outArgsCount = (outArgs == null) ? 0 : outArgs.Length;
                LogicalCallContext callCtx      = (message2 == null) ? null : message2.LogicalCallContext;
                message = new ConstructorReturnMessage(transparentProxy, outArgs, outArgsCount, callCtx, ctorMsg);
                this.SetupIdentity();
                if (this.IsRemotingProxy())
                {
                    ((RemotingProxy)this).Initialized = true;
                }
                return(message);
            }
            return(new ConstructorReturnMessage(e, ctorMsg));
        }
Exemple #4
0
        public IConstructionReturnMessage InitializeServerObject(IConstructionCallMessage ctorMsg)
        {
            IConstructionReturnMessage result = null;

            if (this._serverObject == null)
            {
                Type proxiedType = this.GetProxiedType();
                if (ctorMsg != null && ctorMsg.ActivationType != proxiedType)
                {
                    throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Proxy_BadTypeForActivation"), proxiedType.FullName, ctorMsg.ActivationType));
                }
                this._serverObject = RemotingServices.AllocateUninitializedObject(proxiedType);
                this.SetContextForDefaultStub();
                MarshalByRefObject   marshalByRefObject  = (MarshalByRefObject)this.GetTransparentProxy();
                IMethodReturnMessage methodReturnMessage = null;
                Exception            ex = null;
                if (ctorMsg != null)
                {
                    methodReturnMessage = RemotingServices.ExecuteMessage(marshalByRefObject, ctorMsg);
                    ex = methodReturnMessage.Exception;
                }
                else
                {
                    try
                    {
                        RemotingServices.CallDefaultCtor(marshalByRefObject);
                    }
                    catch (Exception ex2)
                    {
                        ex = ex2;
                    }
                }
                if (ex == null)
                {
                    object[]           array        = (methodReturnMessage == null) ? null : methodReturnMessage.OutArgs;
                    int                outArgsCount = (array == null) ? 0 : array.Length;
                    LogicalCallContext callCtx      = (methodReturnMessage == null) ? null : methodReturnMessage.LogicalCallContext;
                    result = new ConstructorReturnMessage(marshalByRefObject, array, outArgsCount, callCtx, ctorMsg);
                    this.SetupIdentity();
                    if (this.IsRemotingProxy())
                    {
                        ((RemotingProxy)this).Initialized = true;
                    }
                }
                else
                {
                    result = new ConstructorReturnMessage(ex, ctorMsg);
                }
            }
            return(result);
        }
        internal static object DoCrossContextActivationCallback(object[] args)
        {
            IConstructionCallMessage   constructionCallMessage   = (IConstructionCallMessage)args[0];
            IMethodReturnMessage       methodReturnMessage       = (IMethodReturnMessage)Thread.CurrentContext.GetServerContextChain().SyncProcessMessage(constructionCallMessage);
            IConstructionReturnMessage constructionReturnMessage = methodReturnMessage as IConstructionReturnMessage;

            if (constructionReturnMessage == null)
            {
                Exception e;
                if (methodReturnMessage != null)
                {
                    e = methodReturnMessage.Exception;
                }
                else
                {
                    e = new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
                }
                constructionReturnMessage = new ConstructorReturnMessage(e, null);
                ((ConstructorReturnMessage)constructionReturnMessage).SetLogicalCallContext((LogicalCallContext)constructionCallMessage.Properties[Message.CallContextKey]);
            }
            return(constructionReturnMessage);
        }
Exemple #6
0
        private void PrivateInvoke(ref MessageData msgData, int type)
        {
            IMessage      message1      = (IMessage)null;
            CallType      callType      = (CallType)type;
            IMessage      message2      = (IMessage)null;
            int           msgFlags      = -1;
            RemotingProxy remotingProxy = (RemotingProxy)null;

            if (CallType.MethodCall == callType)
            {
                Message     message3 = new Message();
                MessageData msgData1 = msgData;
                message3.InitFields(msgData1);
                message1 = (IMessage)message3;
                msgFlags = message3.GetCallType();
            }
            else if (CallType.ConstructorCall == callType)
            {
                msgFlags      = 0;
                remotingProxy = this as RemotingProxy;
                bool flag = false;
                ConstructorCallMessage constructorCallMessage1;
                if (!this.IsRemotingProxy())
                {
                    constructorCallMessage1 = new ConstructorCallMessage((object[])null, (object[])null, (object[])null, (RuntimeType)this.GetProxiedType());
                }
                else
                {
                    constructorCallMessage1 = remotingProxy.ConstructorMessage;
                    Identity identityObject = remotingProxy.IdentityObject;
                    if (identityObject != null)
                    {
                        flag = identityObject.IsWellKnown();
                    }
                }
                if (constructorCallMessage1 == null | flag)
                {
                    ConstructorCallMessage constructorCallMessage2 = new ConstructorCallMessage((object[])null, (object[])null, (object[])null, (RuntimeType)this.GetProxiedType());
                    constructorCallMessage2.SetFrame(msgData);
                    message1 = (IMessage)constructorCallMessage2;
                    if (flag)
                    {
                        remotingProxy.ConstructorMessage = (ConstructorCallMessage)null;
                        if (constructorCallMessage2.ArgCount != 0)
                        {
                            throw new RemotingException(Environment.GetResourceString("Remoting_Activation_WellKnownCTOR"));
                        }
                    }
                    message2 = (IMessage) new ConstructorReturnMessage((MarshalByRefObject)this.GetTransparentProxy(), (object[])null, 0, (LogicalCallContext)null, (IConstructionCallMessage)constructorCallMessage2);
                }
                else
                {
                    constructorCallMessage1.SetFrame(msgData);
                    message1 = (IMessage)constructorCallMessage1;
                }
            }
            ChannelServices.IncrementRemoteCalls();
            if (!this.IsRemotingProxy() && (msgFlags & 2) == 2)
            {
                message2 = RealProxy.EndInvokeHelper(message1 as Message, true);
            }
            if (message2 == null)
            {
                Thread             currentThread      = Thread.CurrentThread;
                LogicalCallContext logicalCallContext = currentThread.GetMutableExecutionContext().LogicalCallContext;
                this.SetCallContextInMessage(message1, msgFlags, logicalCallContext);
                logicalCallContext.PropagateOutgoingHeadersToMessage(message1);
                message2 = this.Invoke(message1);
                this.ReturnCallContextToThread(currentThread, message2, msgFlags, logicalCallContext);
                Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.PropagateIncomingHeadersToCallContext(message2);
            }
            if (!this.IsRemotingProxy() && (msgFlags & 1) == 1)
            {
                Message     m           = message1 as Message;
                AsyncResult asyncResult = new AsyncResult(m);
                IMessage    msg         = message2;
                asyncResult.SyncProcessMessage(msg);
                // ISSUE: variable of the null type
                __Null local1       = null;
                int    outArgsCount = 0;
                // ISSUE: variable of the null type
                __Null  local2   = null;
                Message message3 = m;
                message2 = (IMessage) new ReturnMessage((object)asyncResult, (object[])local1, outArgsCount, (LogicalCallContext)local2, (IMethodCallMessage)message3);
            }
            RealProxy.HandleReturnMessage(message1, message2);
            if (CallType.ConstructorCall != callType)
            {
                return;
            }
            IConstructionReturnMessage constructionReturnMessage = message2 as IConstructionReturnMessage;

            if (constructionReturnMessage == null)
            {
                throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation"));
            }
            ConstructorReturnMessage constructorReturnMessage = constructionReturnMessage as ConstructorReturnMessage;
            MarshalByRefObject       marshalByRefObject;

            if (constructorReturnMessage != null)
            {
                marshalByRefObject = (MarshalByRefObject)constructorReturnMessage.GetObject();
                if (marshalByRefObject == null)
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullReturnValue"));
                }
            }
            else
            {
                marshalByRefObject = (MarshalByRefObject)RemotingServices.InternalUnmarshal((ObjRef)constructionReturnMessage.ReturnValue, this.GetTransparentProxy(), true);
                if (marshalByRefObject == null)
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal"));
                }
            }
            if (marshalByRefObject != (MarshalByRefObject)this.GetTransparentProxy())
            {
                throw new RemotingException(Environment.GetResourceString("Remoting_Activation_InconsistentState"));
            }
            if (!this.IsRemotingProxy())
            {
                return;
            }
            remotingProxy.ConstructorMessage = (ConstructorCallMessage)null;
        }
        private void PrivateInvoke(ref MessageData msgData, int type)
        {
            IMessage      reqMsg   = null;
            CallType      type2    = (CallType)type;
            IMessage      retMsg   = null;
            int           msgFlags = -1;
            RemotingProxy proxy    = null;

            if (CallType.MethodCall == type2)
            {
                Message message3 = new Message();
                message3.InitFields(msgData);
                reqMsg   = message3;
                msgFlags = message3.GetCallType();
            }
            else if (CallType.ConstructorCall == type2)
            {
                msgFlags = 0;
                proxy    = this as RemotingProxy;
                ConstructorCallMessage ccm = null;
                bool flag = false;
                if (!this.IsRemotingProxy())
                {
                    ccm = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType());
                }
                else
                {
                    ccm = proxy.ConstructorMessage;
                    Identity identityObject = proxy.IdentityObject;
                    if (identityObject != null)
                    {
                        flag = identityObject.IsWellKnown();
                    }
                }
                if ((ccm == null) || flag)
                {
                    ccm = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType());
                    ccm.SetFrame(msgData);
                    reqMsg = ccm;
                    if (flag)
                    {
                        proxy.ConstructorMessage = null;
                        if (ccm.ArgCount != 0)
                        {
                            throw new RemotingException(Environment.GetResourceString("Remoting_Activation_WellKnownCTOR"));
                        }
                    }
                    retMsg = new ConstructorReturnMessage((MarshalByRefObject)this.GetTransparentProxy(), null, 0, null, ccm);
                }
                else
                {
                    ccm.SetFrame(msgData);
                    reqMsg = ccm;
                }
            }
            ChannelServices.IncrementRemoteCalls();
            if (!this.IsRemotingProxy() && ((msgFlags & 2) == 2))
            {
                Message message5 = reqMsg as Message;
                retMsg = EndInvokeHelper(message5, true);
            }
            if (retMsg == null)
            {
                LogicalCallContext cctx          = null;
                Thread             currentThread = Thread.CurrentThread;
                cctx = currentThread.GetLogicalCallContext();
                this.SetCallContextInMessage(reqMsg, msgFlags, cctx);
                cctx.PropagateOutgoingHeadersToMessage(reqMsg);
                retMsg = this.Invoke(reqMsg);
                this.ReturnCallContextToThread(currentThread, retMsg, msgFlags, cctx);
                CallContext.GetLogicalCallContext().PropagateIncomingHeadersToCallContext(retMsg);
            }
            if (!this.IsRemotingProxy() && ((msgFlags & 1) == 1))
            {
                Message     m   = reqMsg as Message;
                AsyncResult ret = new AsyncResult(m);
                ret.SyncProcessMessage(retMsg);
                retMsg = new ReturnMessage(ret, null, 0, null, m);
            }
            HandleReturnMessage(reqMsg, retMsg);
            if (CallType.ConstructorCall == type2)
            {
                MarshalByRefObject         obj2     = null;
                IConstructionReturnMessage message7 = retMsg as IConstructionReturnMessage;
                if (message7 == null)
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation"));
                }
                ConstructorReturnMessage message8 = message7 as ConstructorReturnMessage;
                if (message8 != null)
                {
                    obj2 = (MarshalByRefObject)message8.GetObject();
                    if (obj2 == null)
                    {
                        throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullReturnValue"));
                    }
                }
                else
                {
                    obj2 = (MarshalByRefObject)RemotingServices.InternalUnmarshal((ObjRef)message7.ReturnValue, this.GetTransparentProxy(), true);
                    if (obj2 == null)
                    {
                        throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal"));
                    }
                }
                if (obj2 != ((MarshalByRefObject)this.GetTransparentProxy()))
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Activation_InconsistentState"));
                }
                if (this.IsRemotingProxy())
                {
                    proxy.ConstructorMessage = null;
                }
            }
        }
Exemple #8
0
        [System.Security.SecurityCritical]  // auto-generated
        private void PrivateInvoke(ref MessageData msgData, int type)
        {
            IMessage reqMsg   = null;
            CallType callType = (CallType)type;
            IMessage retMsg   = null;
            int      msgFlags = -1;

            // Used only for Construction case
            RemotingProxy rp = null;

            // Create a message object based on the type of call
            if (CallType.MethodCall == callType)
            {
                Message msg = new Message();
                msg.InitFields(msgData);
                reqMsg   = msg;
                msgFlags = msg.GetCallType();
            }
            else if (CallType.ConstructorCall == (CallType)callType)
            {
                // We use msgFlags to handle CallContext around
                // the virtual call to Invoke()
                msgFlags = Message.Sync;

                rp = this as RemotingProxy;
                ConstructorCallMessage ctorMsg = null;
                bool bIsWellKnown = false;
                if (!IsRemotingProxy())
                {
                    // Create a new constructor call message
                    // <

                    ctorMsg = new ConstructorCallMessage(null, null, null, (RuntimeType)GetProxiedType());
                }
                else
                {
                    // Extract the constructor message set in the first step of activation.
                    ctorMsg = rp.ConstructorMessage;
                    // If the proxy is a wellknown client proxy, we don't
                    // need to run the c'tor.
                    Identity id = rp.IdentityObject;
                    if (id != null)
                    {
                        bIsWellKnown = id.IsWellKnown();
                    }
                }

                if ((null == ctorMsg) || bIsWellKnown)
                {
                    // This is also used to short-circuit the activation path
                    // when we have a well known proxy that has already been
                    // initialized (there's a race condition if we don't do this).
                    //

                    // This is a special case, where we have a remoting proxy
                    // but the constructormessage hasn't been setup.
                    // so let us just bail out..
                    // this is currently used by ServicedComponent's for cross appdomain
                    // pooling: <EMAIL>Microsoft</EMAIL>
                    //
                    ctorMsg = new ConstructorCallMessage(null, null, null, (RuntimeType)GetProxiedType());
                    // Set the constructor frame info in the CCM
                    ctorMsg.SetFrame(msgData);
                    reqMsg = ctorMsg;

                    // If this was the default ctor, check that default .ctor was called.
                    if (bIsWellKnown)
                    {
                        Contract.Assert(rp != null, "RemotingProxy expected here!");
                        // Clear any cached ctorMsg on the RemotingProxy
                        rp.ConstructorMessage = null;

                        // We did execute a Connect. Throw if the client
                        // code is also trying to use a non-default constructor at
                        // the same time.
                        if (ctorMsg.ArgCount != 0)
                        {
                            throw new RemotingException(
                                      Environment.GetResourceString(
                                          "Remoting_Activation_WellKnownCTOR"));
                        }
                    }

                    // Create a constructor return message
                    retMsg =
                        new ConstructorReturnMessage((MarshalByRefObject)GetTransparentProxy(),
                                                     null,
                                                     0,
                                                     null,
                                                     ctorMsg);
                }
                else
                {
                    // Set the constructor frame info in the CCM
                    ctorMsg.SetFrame(msgData);
                    reqMsg = ctorMsg;
                }
            }
            else
            {
                Contract.Assert(false, "Unknown call type");
            }

            // Make sure that outgoing remote calls are counted.
            ChannelServices.IncrementRemoteCalls();

            // For non-remoting proxies, EndAsync should not call Invoke()
            // because the proxy cannot support Async and the call has already
            // finished executing in BeginAsync
            if (!IsRemotingProxy() &&
                ((msgFlags & Message.EndAsync) == Message.EndAsync))
            {
                Message msg = reqMsg as Message;
                retMsg = EndInvokeHelper(msg, true);
                Contract.Assert(null != retMsg, "null != retMsg");
            }

            // Invoke
            Contract.Assert(null != reqMsg, "null != reqMsg");
            if (null == retMsg)
            {
                // NOTE: there are cases where we setup a return message
                // and we don't want the activation call to go through
                // refer to the note above for ServicedComponents and Cross Appdomain
                // pooling

                LogicalCallContext cctx          = null;
                Thread             currentThread = Thread.CurrentThread;
                // Pick up or clone the call context from the thread
                // and install it in the reqMsg as appropriate
                cctx = currentThread.GetMutableExecutionContext().LogicalCallContext;
                SetCallContextInMessage(reqMsg, msgFlags, cctx);

                // Add the outgoing "Header"'s to the message.
                cctx.PropagateOutgoingHeadersToMessage(reqMsg);
                retMsg = Invoke(reqMsg);

                // Get the call context returned and set it on the thread
                ReturnCallContextToThread(currentThread, retMsg, msgFlags, cctx);

                // Pull response "Header"'s out of the message
                Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.PropagateIncomingHeadersToCallContext(retMsg);
            }

            if (!IsRemotingProxy() &&
                ((msgFlags & Message.BeginAsync) == Message.BeginAsync))
            {
                // This was a begin-async on a non-Remoting Proxy. For V-1 they
                // cannot support Async and end up doing a Sync call. We need
                // to fill up here to make the call look like async to
                // the caller.
                // Create the async result to return
                Message     msg = reqMsg as Message;
                AsyncResult ar  = new AsyncResult(msg);
                // Tell the async result that the call has actually completed
                // so it can hold on to the return message.
                ar.SyncProcessMessage(retMsg);
                // create a returnMessage to propagate just the asyncResult back
                // to the caller's stack.
                retMsg = new ReturnMessage(ar, null, 0, null /*cctx*/, msg);
            }

            // Propagate out parameters
            HandleReturnMessage(reqMsg, retMsg);

            // For constructor calls do some extra bookkeeping
            if (CallType.ConstructorCall == callType)
            {
                // NOTE: It is the responsiblity of the callee to propagate
                // the out parameters

                // Everything went well, we are ready to return
                // a proxy to the caller
                // Extract the return value
                MarshalByRefObject         retObj     = null;
                IConstructionReturnMessage ctorRetMsg = retMsg as IConstructionReturnMessage;
                if (null == ctorRetMsg)
                {
                    throw new RemotingException(
                              Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation"));
                }

                ConstructorReturnMessage crm = ctorRetMsg as ConstructorReturnMessage;
                if (null != crm)
                {
                    // If return message is of type ConstructorReturnMessage
                    // this is an in-appDomain activation. So no unmarshaling
                    // needed.

                    retObj = (MarshalByRefObject)crm.GetObject();
                    if (retObj == null)
                    {
                        throw new RemotingException(
                                  Environment.GetResourceString("Remoting_Activation_NullReturnValue"));
                    }
                }
                else
                {
                    // Fetch the objRef out of the returned message and unmarshal it
                    retObj = (MarshalByRefObject)RemotingServices.InternalUnmarshal(
                        (ObjRef)ctorRetMsg.ReturnValue,
                        GetTransparentProxy(),
                        true /*fRefine*/);

                    if (retObj == null)
                    {
                        throw new RemotingException(
                                  Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal"));
                    }
                }

                if (retObj != (MarshalByRefObject)GetTransparentProxy())
                {
                    throw new RemotingException(
                              Environment.GetResourceString(
                                  "Remoting_Activation_InconsistentState"));
                }

                if (IsRemotingProxy())
                {
                    // Clear any cached ctorMsg on the RemotingProxy
                    rp.ConstructorMessage = null;
                }
            }
        }
Exemple #9
0
        public IConstructionReturnMessage InitializeServerObject(IConstructionCallMessage ctorMsg)
        {
            IConstructionReturnMessage retMsg = null;

            if (_serverObject == null)
            {
                Type svrType = GetProxiedType();
                if ((ctorMsg != null) && (ctorMsg.ActivationType != svrType))
                {
                    throw new RemotingException(
                              String.Format(
                                  CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Proxy_BadTypeForActivation"),
                                  svrType.FullName,
                                  ctorMsg.ActivationType));
                }

                // Create a blank object
                _serverObject = RemotingServices.AllocateUninitializedObject(svrType);

                // If the stub is the default stub, then set the server context
                // to be the current context.
                SetContextForDefaultStub();

                // OK... we are all set to run the constructor call on the uninitialized object
                MarshalByRefObject   proxy = (MarshalByRefObject)GetTransparentProxy();
                IMethodReturnMessage msg   = null;
                Exception            e     = null;
                if (null != ctorMsg)
                {
                    msg = RemotingServices.ExecuteMessage(proxy, ctorMsg);
                    e   = msg.Exception;
                }
                else
                {
                    try
                    {
                        RemotingServices.CallDefaultCtor(proxy);
                    }
                    catch (Exception excep)
                    {
                        e = excep;
                    }
                }

                // Construct a return message
                if (null == e)
                {
                    Object[]           outArgs   = (msg == null ? null : msg.OutArgs);
                    int                outLength = (null == outArgs ? 0 : outArgs.Length);
                    LogicalCallContext callCtx   = (msg == null ? null : msg.LogicalCallContext);
                    retMsg = new ConstructorReturnMessage(proxy,
                                                          outArgs, outLength,
                                                          callCtx, ctorMsg);

                    // setup identity
                    SetupIdentity();
                    if (IsRemotingProxy())
                    {
                        ((RemotingProxy)this).Initialized = true;
                    }
                }
                else
                {
                    // Exception occurred
                    retMsg = new ConstructorReturnMessage(e, ctorMsg);
                }
            }


            return(retMsg);
        }
Exemple #10
0
        // Private method invoked by the transparent proxy
        private void PrivateInvoke(ref MessageData msgData, int type)
        {
            IMessage reqMsg   = null;
            CallType callType = (CallType)type;
            IMessage retMsg   = null;
            int      msgFlags = -1;

            // Create a message object based on the type of call
            if (CallType.MethodCall == callType)
            {
                Message msg = new Message();
                msg.InitFields(msgData);
                reqMsg   = msg;
                msgFlags = msg.GetCallType();
            }
            else if (CallType.ConstructorCall == (CallType)callType)
            {
                // We use msgFlags to handle CallContext around
                // the virtual call to Invoke()
                msgFlags = Message.Sync;

                ConstructorCallMessage ctorMsg = null;
                RemotingProxy          rp      = this as RemotingProxy;
                if (null == rp)
                {
                    // Create a new constructor call message
                    ctorMsg = new ConstructorCallMessage(null, null, null, GetProxiedType());
                }
                else
                {
                    // Extract the constructor message set in the first step of activation.
                    ctorMsg = rp.ConstructorMessage;
                }

                // If the proxy is a wellknown client proxy, we don't need to run the c'tor.
                bool bIsWellKnown = false;
                if (rp != null)
                {
                    Identity id = rp.IdentityObject;
                    if (id != null)
                    {
                        bIsWellKnown = id.IsWellKnown();
                    }
                }

                if ((null == ctorMsg) || bIsWellKnown)
                {
                    // This is also used to short-circuit the activation path
                    // when we have a well known proxy that has already been
                    // initialized (there's a race condition if we don't do this).
                    //

                    // This is a special case, where we have a remoting proxy
                    // but the constructormessage hasn't been setup.
                    // so let us just bail out..
                    // this is currently used by ServicedComponent's for cross appdomain
                    // pooling:
                    //

                    /*
                     * ProxyAttribute pa = null;
                     * BCLDebug.Assert(((pa = ActivationServices.GetProxyAttribute(GetProxiedType()) is Object) || true);
                     * BCLDebug.Assert(pa != null && pa.GetType() != typeof(ProxyAttribute));
                     */
                    ctorMsg = new ConstructorCallMessage(null, null, null, GetProxiedType());
                    // Set the constructor frame info in the CCM
                    ctorMsg.SetFrame(msgData);
                    reqMsg = ctorMsg;

                    // If this was the default ctor, check that default .ctor was called.
                    if (bIsWellKnown)
                    {
                        // We did execute a Connect. Throw if the client
                        // code is also trying to use a non-default constructor at
                        // the same time.
                        if (ctorMsg.ArgCount != 0)
                        {
                            throw new RemotingException(
                                      Environment.GetResourceString(
                                          "Remoting_Activation_WellKnownCTOR"));
                        }
                    }

                    // Create a constructor return message
                    retMsg =
                        new ConstructorReturnMessage((MarshalByRefObject)GetTransparentProxy(),
                                                     null,
                                                     0,
                                                     null,
                                                     ctorMsg);
                }
                else
                {
                    // Set the constructor frame info in the CCM
                    ctorMsg.SetFrame(msgData);
                    reqMsg = ctorMsg;
                }
            }
            else
            {
                BCLDebug.Assert(false, "Unknown call type");
            }

            // Make sure that outgoing remote calls are counted.
            ChannelServices.IncrementRemoteCalls();


            // Invoke
            BCLDebug.Assert(null != reqMsg, "null != reqMsg");
            if (null == retMsg)
            {
                // NOTE: there are cases where we setup a return message
                // and we don't want the activation call to go through
                // refer to the note above for ServicedComponents and Cross Appdomain
                // pooling

                LogicalCallContext cctx          = null;
                Thread             currentThread = Thread.CurrentThread;
                // Pick up or clone the call context from the thread
                // and install it in the reqMsg as appropriate
                cctx = currentThread.GetLogicalCallContext();
                SetCallContextInMessage(reqMsg, msgFlags, cctx);

                // Add the outgoing "Header"'s to the message.
                cctx.PropagateOutgoingHeadersToMessage(reqMsg);

                retMsg = Invoke(reqMsg);

                // Get the call context returned and set it on the thread
                ReturnCallContextToThread(currentThread, retMsg, msgFlags);

                // Pull response "Header"'s out of the message
                CallContext.GetLogicalCallContext().PropagateIncomingHeadersToCallContext(retMsg);
            }

            // Propagate out parameters
            HandleReturnMessage(reqMsg, retMsg);

            // For constructor calls do some extra bookkeeping
            if (CallType.ConstructorCall == callType)
            {
                // NOTE: It is the responsiblity of the callee to propagate
                // the out parameters

                // Everything went well, we are ready to return
                // a proxy to the caller
                // Extract the return value
                MarshalByRefObject         retObj     = null;
                IConstructionReturnMessage ctorRetMsg = retMsg as IConstructionReturnMessage;
                if (null == ctorRetMsg)
                {
                    throw new RemotingException(
                              Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation"));
                }

                ConstructorReturnMessage crm = ctorRetMsg as ConstructorReturnMessage;
                if (null != crm)
                {
                    retObj = (MarshalByRefObject)crm.GetObject();
                    if (retObj == null)
                    {
                        throw new RemotingException(
                                  Environment.GetResourceString("Remoting_Activation_NullReturnValue"));
                    }
                }
                else
                {
                    // Fetch the objRef out of the returned message and unmarshal it
                    retObj = (MarshalByRefObject)RemotingServices.InternalUnmarshal(
                        (ObjRef)ctorRetMsg.ReturnValue,
                        GetTransparentProxy(),
                        true /*fRefine*/);

                    if (retObj == null)
                    {
                        throw new RemotingException(
                                  Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal"));
                    }
                }

                if (retObj != (MarshalByRefObject)GetTransparentProxy())
                {
                    throw new RemotingException(
                              Environment.GetResourceString(
                                  "Remoting_Activation_InconsistentState"));
                }
            }
        }
Exemple #11
0
        private void PrivateInvoke(ref MessageData msgData, int type)
        {
            IMessage      message       = null;
            IMessage      message2      = null;
            int           num           = -1;
            RemotingProxy remotingProxy = null;

            if (1 == type)
            {
                Message message3 = new Message();
                message3.InitFields(msgData);
                message = message3;
                num     = message3.GetCallType();
            }
            else if (2 == type)
            {
                num           = 0;
                remotingProxy = (this as RemotingProxy);
                bool flag = false;
                ConstructorCallMessage constructorCallMessage;
                if (!this.IsRemotingProxy())
                {
                    constructorCallMessage = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType());
                }
                else
                {
                    constructorCallMessage = remotingProxy.ConstructorMessage;
                    Identity identityObject = remotingProxy.IdentityObject;
                    if (identityObject != null)
                    {
                        flag = identityObject.IsWellKnown();
                    }
                }
                if (constructorCallMessage == null || flag)
                {
                    constructorCallMessage = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType());
                    constructorCallMessage.SetFrame(msgData);
                    message = constructorCallMessage;
                    if (flag)
                    {
                        remotingProxy.ConstructorMessage = null;
                        if (constructorCallMessage.ArgCount != 0)
                        {
                            throw new RemotingException(Environment.GetResourceString("Remoting_Activation_WellKnownCTOR"));
                        }
                    }
                    message2 = new ConstructorReturnMessage((MarshalByRefObject)this.GetTransparentProxy(), null, 0, null, constructorCallMessage);
                }
                else
                {
                    constructorCallMessage.SetFrame(msgData);
                    message = constructorCallMessage;
                }
            }
            ChannelServices.IncrementRemoteCalls();
            if (!this.IsRemotingProxy() && (num & 2) == 2)
            {
                Message reqMsg = message as Message;
                message2 = RealProxy.EndInvokeHelper(reqMsg, true);
            }
            if (message2 == null)
            {
                Thread             currentThread      = Thread.CurrentThread;
                LogicalCallContext logicalCallContext = currentThread.GetMutableExecutionContext().LogicalCallContext;
                this.SetCallContextInMessage(message, num, logicalCallContext);
                logicalCallContext.PropagateOutgoingHeadersToMessage(message);
                message2 = this.Invoke(message);
                this.ReturnCallContextToThread(currentThread, message2, num, logicalCallContext);
                Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.PropagateIncomingHeadersToCallContext(message2);
            }
            if (!this.IsRemotingProxy() && (num & 1) == 1)
            {
                Message     message4    = message as Message;
                AsyncResult asyncResult = new AsyncResult(message4);
                asyncResult.SyncProcessMessage(message2);
                message2 = new ReturnMessage(asyncResult, null, 0, null, message4);
            }
            RealProxy.HandleReturnMessage(message, message2);
            if (2 == type)
            {
                IConstructionReturnMessage constructionReturnMessage = message2 as IConstructionReturnMessage;
                if (constructionReturnMessage == null)
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation"));
                }
                ConstructorReturnMessage constructorReturnMessage = constructionReturnMessage as ConstructorReturnMessage;
                MarshalByRefObject       marshalByRefObject;
                if (constructorReturnMessage != null)
                {
                    marshalByRefObject = (MarshalByRefObject)constructorReturnMessage.GetObject();
                    if (marshalByRefObject == null)
                    {
                        throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullReturnValue"));
                    }
                }
                else
                {
                    marshalByRefObject = (MarshalByRefObject)RemotingServices.InternalUnmarshal((ObjRef)constructionReturnMessage.ReturnValue, this.GetTransparentProxy(), true);
                    if (marshalByRefObject == null)
                    {
                        throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal"));
                    }
                }
                if (marshalByRefObject != (MarshalByRefObject)this.GetTransparentProxy())
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Activation_InconsistentState"));
                }
                if (this.IsRemotingProxy())
                {
                    remotingProxy.ConstructorMessage = null;
                }
            }
        }