private LogicalCallContext FetchLogicalCallContext() { ConstructorCallMessage message = this._ccmsg as ConstructorCallMessage; if (message != null) { return(message.GetLogicalCallContext()); } if (!(this._ccmsg is ConstructionCall)) { throw new RemotingException(Environment.GetResourceString("Remoting_Message_BadType")); } return(((MethodCall)this._ccmsg).GetLogicalCallContext()); }
[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; } } }
[System.Security.SecurityCritical] // auto-generated private static bool IsCurrentContextOK(RuntimeType serverType, Object[] props, ref ConstructorCallMessage ctorCallMsg) { //Get callSite attributes Object[] callSiteAttr = PeekActivationAttributes(serverType); // Clear from the attribute stack if (callSiteAttr != null) { PopActivationAttributes(serverType); } Object[] womAttr = new Object[1]; womAttr[0] = GetGlobalAttribute(); // Get the type context attributes Object[] typeAttr = GetContextAttributesForType(serverType); // Get the client context (current context) Context cliCtx = Thread.CurrentContext; // Create a ctorCallMsg with the reqd info ctorCallMsg = new ConstructorCallMessage( callSiteAttr, womAttr, typeAttr, serverType); // This is the activator that handles activation in *all* cases // Based on whether what the activation attributes do.... other // activators may get chained ahead of this one and may take // over the activation process... (possibly) delegating to this // only in the last stage. // Note: currently, this does not get used in the same context (MBR) // scenarios ... because of the 2-step activation model of JIT. ctorCallMsg.Activator = new ConstructionLevelActivator(); // Ask all attributes if they are happy with the current context // NOTE: if someone says no, we do not ask the rest of the attributes // This is why, womAttr (which is the global activation service // attribute) *must* be the first one we query. bool bCtxOK = QueryAttributesIfContextOK(cliCtx, ctorCallMsg, womAttr); if (bCtxOK == true) { bCtxOK = QueryAttributesIfContextOK(cliCtx, ctorCallMsg, callSiteAttr); if (bCtxOK == true) { bCtxOK = QueryAttributesIfContextOK(cliCtx, ctorCallMsg, typeAttr); } } return bCtxOK; }
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; } } }
private static bool IsCurrentContextOK(RuntimeType serverType, object[] props, ref ConstructorCallMessage ctorCallMsg) { object[] callSiteActivationAttributes = PeekActivationAttributes(serverType); if (callSiteActivationAttributes != null) { PopActivationAttributes(serverType); } object[] womAttr = new object[] { GetGlobalAttribute() }; object[] contextAttributesForType = GetContextAttributesForType(serverType); Context currentContext = Thread.CurrentContext; ctorCallMsg = new ConstructorCallMessage(callSiteActivationAttributes, womAttr, contextAttributesForType, serverType); ctorCallMsg.Activator = new ConstructionLevelActivator(); bool flag = QueryAttributesIfContextOK(currentContext, ctorCallMsg, womAttr); if (flag) { flag = QueryAttributesIfContextOK(currentContext, ctorCallMsg, callSiteActivationAttributes); if (flag) { flag = QueryAttributesIfContextOK(currentContext, ctorCallMsg, contextAttributesForType); } } return flag; }
// 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")); } } }