internal RedirectionProxy(MarshalByRefObject proxy, Type serverType) { _proxy = proxy; _realProxy = RemotingServices.GetRealProxy(_proxy); _serverType = serverType; _objectMode = WellKnownObjectMode.Singleton; } // RedirectionProxy
// Default implementation of CreateProxy creates an instance of our // remoting proxy /// <include file='doc\ProxyAttribute.uex' path='docs/doc[@for="ProxyAttribute.CreateProxy"]/*' /> public virtual RealProxy CreateProxy(ObjRef objRef, Type serverType, Object serverObject, Context serverContext) { RemotingProxy rp = new RemotingProxy(serverType); // If this is a serverID, set the native context field in the TP if (null != serverContext) { RealProxy.SetStubData(rp, serverContext.InternalContextID); } // Set the flag indicating that the fields of the proxy // have been initialized rp.Initialized = true; // Sanity check Type t = serverType; if (!t.IsContextful && !t.IsMarshalByRef && (null != serverContext)) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_MBR_ProxyAttribute")); } return(rp); }
internal object LoadRemoteFieldNew(IntPtr classPtr, IntPtr fieldPtr) { Mono.RuntimeClassHandle classHandle = new Mono.RuntimeClassHandle(classPtr); RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle(fieldPtr); RuntimeTypeHandle typeHandle = classHandle.GetTypeHandle(); FieldInfo field = FieldInfo.GetFieldFromHandle(fieldHandle); if (InCurrentContext()) { object o = _rp._server; return(field.GetValue(o)); } object[] inArgs = new object[] { Type.GetTypeFromHandle(typeHandle).FullName, field.Name }; object[] outArgsMsg = new object[1]; MethodInfo minfo = typeof(object).GetMethod("FieldGetter", BindingFlags.NonPublic | BindingFlags.Instance); if (minfo == null) { throw new MissingMethodException("System.Object", "FieldGetter"); } MonoMethodMessage msg = new MonoMethodMessage(minfo, inArgs, outArgsMsg); object[] outArgs; Exception exc; RealProxy.PrivateInvoke(_rp, msg, out exc, out outArgs); if (exc != null) { throw exc; } return(outArgs[0]); }
internal SCUnMarshaler(Type _servertype, byte[] _buffer) { this.buffer = _buffer; this.servertype = _servertype; this._rp = null; this._fUnMarshaled = false; }
protected ServicedComponentMarshaler(SerializationInfo info, StreamingContext context) : base(info, context) { byte[] buffer = null; Type type = null; bool flag = false; ComponentServices.InitializeRemotingChannels(); SerializationInfoEnumerator enumerator = info.GetEnumerator(); while (enumerator.MoveNext()) { if (enumerator.Name.Equals("servertype")) { type = (Type) enumerator.Value; } else { if (enumerator.Name.Equals("dcomInfo")) { buffer = (byte[]) enumerator.Value; continue; } if (enumerator.Name.Equals("fIsMarshalled")) { int num = 0; object obj2 = enumerator.Value; if (obj2.GetType() == typeof(string)) { num = ((IConvertible) obj2).ToInt32(null); } else { num = (int) obj2; } if (num == 0) { flag = true; } } } } if (!flag) { this._marshalled = true; } this._um = new SCUnMarshaler(type, buffer); this._rt = type; if (base.IsFromThisProcess() && !ServicedComponentInfo.IsTypeEventSource(type)) { this._rp = RemotingServices.GetRealProxy(base.GetRealObject(context)); } else { if (ServicedComponentInfo.IsTypeEventSource(type)) { this.TypeInfo = new SCMTypeName(type); } object realObject = base.GetRealObject(context); this._rp = RemotingServices.GetRealProxy(realObject); } this._um.Dispose(); }
private static void HandleReturnMessage(IMessage reqMsg, IMessage retMsg) { IMethodReturnMessage methodReturnMessage = retMsg as IMethodReturnMessage; if (retMsg == null || methodReturnMessage == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Message_BadType")); } Exception exception = methodReturnMessage.Exception; if (exception != null) { throw exception.PrepForRemoting(); } if (retMsg is StackBasedReturnMessage) { return; } if (reqMsg is Message) { RealProxy.PropagateOutParameters(reqMsg, methodReturnMessage.Args, methodReturnMessage.ReturnValue); } else { if (!(reqMsg is ConstructorCallMessage)) { return; } RealProxy.PropagateOutParameters(reqMsg, methodReturnMessage.Args, (object)null); } }
public static void SwitchWrappers(RealProxy oldcp, RealProxy newcp) { object transparentProxy = oldcp.GetTransparentProxy(); object tp = newcp.GetTransparentProxy(); RemotingServices.GetServerContextForProxy(transparentProxy); RemotingServices.GetServerContextForProxy(tp); Marshal.InternalSwitchCCW(transparentProxy, tp); }
internal RealProxy GetRealProxy() { if ((this._rp == null) && !this._fUnMarshaled) { this._rp = this.UnmarshalRemoteReference(); } return this._rp; }
public RemotingInvocation(RealProxy proxy, IMethodCallMessage message) { this.message = message; this.proxy = proxy; arguments = message.Args; if (arguments == null) arguments = new object[0]; }
internal virtual void Wrap() { ServerIdentity serverIdentity = this._identity as ServerIdentity; if (serverIdentity != null && this is RemotingProxy) { RealProxy.SetStubData(this, serverIdentity.ServerContext.InternalContextID); } }
private IntPtr _stub; // Unmanaged code that decides whether to short circuit calls or not // This method should never be called. Its sole purpose is to shut up the compiler // because it warns about private fields that are never used. Most of these fields // are used in unmanaged code. #if _DEBUG private int NeverCallThis() { BCLDebug.Assert(false,"NeverCallThis"); _rp = null; _pMT = new IntPtr(RemotingServices.TrashMemory); _pInterfaceMT = new IntPtr(RemotingServices.TrashMemory); _stub = new IntPtr(RemotingServices.TrashMemory); RealProxy rp = _rp; return _pInterfaceMT.ToInt32(); }
private static void InvokeRealProxy(RealProxy realProxy, WcfInvocation wcfInvocation) { var message = new MethodCallMessage(wcfInvocation.Method, wcfInvocation.Arguments); var returnMessage = (IMethodReturnMessage)realProxy.Invoke(message); if (returnMessage.Exception != null) { throw returnMessage.Exception; } wcfInvocation.ReturnValue = returnMessage.ReturnValue; }
internal virtual void Wrap() { ServerIdentity serverIdentity = this._identity as ServerIdentity; if (serverIdentity == null || !(this is RemotingProxy)) { return; } RealProxy.SetStubData(this, (object)serverIdentity.ServerContext.InternalContextID); }
private IntPtr _stub; // Unmanaged code that decides whether to short circuit calls or not // This method should never be called. Its sole purpose is to shut up the compiler // because it warns about private fields that are never used. Most of these fields // are used in unmanaged code. #if _DEBUG private int NeverCallThis() { BCLDebug.Assert(false, "NeverCallThis"); _rp = null; _pMT = new IntPtr(RemotingServices.TrashMemory); _pInterfaceMT = new IntPtr(RemotingServices.TrashMemory); _stub = new IntPtr(RemotingServices.TrashMemory); RealProxy rp = _rp; return(_pInterfaceMT.ToInt32()); }
private static void InvokeRealProxy(RealProxy realProxy, WcfInvocation wcfInvocation) { var message = new MethodCallMessage(wcfInvocation.Method, wcfInvocation.Arguments); var returnMessage = (IMethodReturnMessage)realProxy.Invoke(message); if (returnMessage.Exception != null) { var exception = ExceptionHelper.PreserveStackTrace(returnMessage.Exception); throw exception; } wcfInvocation.ReturnValue = returnMessage.ReturnValue; }
private void SetContextForDefaultStub() { if (this.GetStub() == RealProxy._defaultStub) { object stubData = RealProxy.GetStubData(this); if (stubData is IntPtr && ((IntPtr)stubData).Equals(RealProxy._defaultStubValue)) { RealProxy.SetStubData(this, Thread.CurrentContext.InternalContextID); } } }
// Get the stub data within a proxy. public static Object GetStubData(RealProxy rp) { if (rp != null) { return(rp.stubData); } else { return(null); } }
[System.Security.SecurityCritical] // auto-generated_required public static void SwitchWrappers(RealProxy oldcp, RealProxy newcp) { Object oldtp = oldcp.GetTransparentProxy(); Object newtp = newcp.GetTransparentProxy(); IntPtr oldcontextId = RemotingServices.GetServerContextForProxy(oldtp); IntPtr newcontextId = RemotingServices.GetServerContextForProxy(newtp); // switch the CCW from oldtp to new tp Marshal.InternalSwitchCCW(oldtp, newtp); }
public ObjectCall( RealProxy proxy, IMessage callMessage, Action<IConstructionCallMessage> validationOnInit = null, Action<IMethodCallMessage> validationOnAction = null) { this.proxy = proxy; this.callMessage = callMessage; this.validationOnInit = validationOnInit; this.validationOnAction = validationOnAction; }
/// <summary>Returns the <see cref="T:System.Type" /> of the object that the current instance of <see cref="T:System.Runtime.Remoting.Proxies.RealProxy" /> represents.</summary> /// <returns>The <see cref="T:System.Type" /> of the object that the current instance of <see cref="T:System.Runtime.Remoting.Proxies.RealProxy" /> represents.</returns> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure" /> /// </PermissionSet> public Type GetProxiedType() { if (this._objTP != null) { return(RealProxy.InternalGetProxyType(this._objTP)); } if (this.class_to_proxy.IsInterface) { return(typeof(MarshalByRefObject)); } return(this.class_to_proxy); }
private void SetContextForDefaultStub() { if (!(this.GetStub() == RealProxy._defaultStub)) { return; } object stubData = RealProxy.GetStubData(this); if (!(stubData is IntPtr) || !((IntPtr)stubData).Equals((object)RealProxy._defaultStubValue)) { return; } RealProxy.SetStubData(this, (object)Thread.CurrentContext.InternalContextID); }
internal bool DoContextsMatch() { bool flag = false; if (this.GetStub() == RealProxy._defaultStub) { object stubData = RealProxy.GetStubData(this); if (stubData is IntPtr && ((IntPtr)stubData).Equals((object)Thread.CurrentContext.InternalContextID)) { flag = true; } } return(flag); }
private static void Invoke(object NotUsed, ref MessageData msgData) { Message reqMcmMsg = new Message(); reqMcmMsg.InitFields(msgData); Delegate thisPtr = reqMcmMsg.GetThisPtr() as Delegate; if (thisPtr == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Default")); } RemotingProxy realProxy = (RemotingProxy)RemotingServices.GetRealProxy(thisPtr.Target); if (realProxy != null) { realProxy.InternalInvoke(reqMcmMsg, true, reqMcmMsg.GetCallType()); } else { int callType = reqMcmMsg.GetCallType(); switch (callType) { case 1: case 9: { reqMcmMsg.Properties[Message.CallContextKey] = CallContext.GetLogicalCallContext().Clone(); AsyncResult retVal = new AsyncResult(reqMcmMsg); AgileAsyncWorkerItem state = new AgileAsyncWorkerItem(reqMcmMsg, ((callType & 8) != 0) ? null : retVal, thisPtr.Target); ThreadPool.QueueUserWorkItem(new WaitCallback(AgileAsyncWorkerItem.ThreadPoolCallBack), state); if ((callType & 8) != 0) { retVal.SyncProcessMessage(null); } reqMcmMsg.PropagateOutParameters(null, retVal); break; } case 2: RealProxy.EndInvokeHelper(reqMcmMsg, false); return; case 10: break; default: return; } } }
// Token: 0x06005742 RID: 22338 RVA: 0x00133030 File Offset: 0x00131230 private static void Invoke(object NotUsed, ref MessageData msgData) { Message message = new Message(); message.InitFields(msgData); object thisPtr = message.GetThisPtr(); Delegate @delegate; if ((@delegate = (thisPtr as Delegate)) == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Default")); } RemotingProxy remotingProxy = (RemotingProxy)RemotingServices.GetRealProxy(@delegate.Target); if (remotingProxy != null) { remotingProxy.InternalInvoke(message, true, message.GetCallType()); return; } int callType = message.GetCallType(); if (callType <= 2) { if (callType != 1) { if (callType != 2) { return; } RealProxy.EndInvokeHelper(message, false); return; } } else if (callType != 9) { return; } message.Properties[Message.CallContextKey] = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.Clone(); AsyncResult asyncResult = new AsyncResult(message); AgileAsyncWorkerItem state = new AgileAsyncWorkerItem(message, ((callType & 8) != 0) ? null : asyncResult, @delegate.Target); ThreadPool.QueueUserWorkItem(new WaitCallback(AgileAsyncWorkerItem.ThreadPoolCallBack), state); if ((callType & 8) != 0) { asyncResult.SyncProcessMessage(null); } message.PropagateOutParameters(null, asyncResult); }
public virtual RealProxy CreateProxy(ObjRef objRef, Type serverType, object serverObject, Context serverContext) { RemotingProxy remotingProxy = new RemotingProxy(serverType); if (serverContext != null) { RealProxy.SetStubData(remotingProxy, serverContext.InternalContextID); } if (objRef != null && objRef.GetServerIdentity().IsAllocated) { remotingProxy.SetSrvInfo(objRef.GetServerIdentity(), objRef.GetDomainID()); } remotingProxy.Initialized = true; if (!serverType.IsContextful && !serverType.IsMarshalByRef && serverContext != null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_MBR_ProxyAttribute")); } return(remotingProxy); }
internal void StoreRemoteField(IntPtr classPtr, IntPtr fieldPtr, object arg) { Mono.RuntimeClassHandle classHandle = new Mono.RuntimeClassHandle(classPtr); RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle(fieldPtr); RuntimeTypeHandle typeHandle = classHandle.GetTypeHandle(); FieldInfo field = FieldInfo.GetFieldFromHandle(fieldHandle); if (InCurrentContext()) { object o = _rp._server; field.SetValue(o, arg); return; } string typeName = Type.GetTypeFromHandle(typeHandle).FullName; string fieldName = field.Name; object [] inArgs = new object[] { typeName, fieldName, arg }; MethodInfo minfo = typeof(object).GetMethod("FieldSetter", BindingFlags.NonPublic | BindingFlags.Instance); if (minfo == null) { throw new MissingMethodException("System.Object", "FieldSetter"); } MonoMethodMessage msg = new MonoMethodMessage(minfo, inArgs, null); object [] outArgs; Exception exc; RealProxy.PrivateInvoke(_rp, msg, out exc, out outArgs); if (exc != null) { throw exc; } }
public static extern void SetStubData(RealProxy rp, Object stubData);
public static void SetStubData(RealProxy rp, object stubData) { rp._stubData = stubData; }
// // Summary: // Sets the stub data for the specified proxy. // // Parameters: // rp: // The proxy for which to set stub data. // // stubData: // The new stub data. // // Exceptions: // System.Security.SecurityException: // The immediate caller does not have UnmanagedCode permission. public static void SetStubData(RealProxy rp, object stubData);
[System.Security.SecurityCritical] // auto-generated internal static Object CreateTransparentProxy( RealProxy rp, Type typeToProxy, IntPtr stub, Object stubData) { RuntimeType rTypeToProxy = typeToProxy as RuntimeType; if (rTypeToProxy == null) throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_WrongType"), "typeToProxy" ) ); return CreateTransparentProxy( rp, rTypeToProxy, stub, stubData); }
[System.Security.SecurityCritical] // auto-generated internal static bool ProxyCheckCast(RealProxy rp, RuntimeType castType) { return CheckCast(rp, castType); } // ProxyCheckCast
public static extern Object GetStubData(RealProxy rp);
public StackBuilderSink (MarshalByRefObject obj, bool forceInternalExecute) { _target = obj; if (!forceInternalExecute && RemotingServices.IsTransparentProxy (obj)) _rp = RemotingServices.GetRealProxy (obj); }
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; }
internal static void PropagateOutParameters(IMessage msg, object[] outArgs, object returnValue) { Message message = msg as Message; if (message == null) { ConstructorCallMessage constructorCallMessage = msg as ConstructorCallMessage; if (constructorCallMessage != null) { message = constructorCallMessage.GetMessage(); } } if (message == null) { throw new ArgumentException(Environment.GetResourceString("Remoting_Proxy_ExpectedOriginalMessage")); } RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(message.GetMethodBase()); if (outArgs != null && outArgs.Length != 0) { object[] args = message.Args; ParameterInfo[] parameters = reflectionCachedData.Parameters; foreach (int marshalRequestArg in reflectionCachedData.MarshalRequestArgMap) { ParameterInfo parameterInfo = parameters[marshalRequestArg]; if (parameterInfo.IsIn && parameterInfo.ParameterType.IsByRef && !parameterInfo.IsOut) { outArgs[marshalRequestArg] = args[marshalRequestArg]; } } if (reflectionCachedData.NonRefOutArgMap.Length != 0) { foreach (int nonRefOutArg in reflectionCachedData.NonRefOutArgMap) { Array array = args[nonRefOutArg] as Array; if (array != null) { Array sourceArray = (Array)outArgs[nonRefOutArg]; Array destinationArray = array; int length = destinationArray.Length; Array.Copy(sourceArray, destinationArray, length); } } } int[] outRefArgMap = reflectionCachedData.OutRefArgMap; if (outRefArgMap.Length != 0) { foreach (int index in outRefArgMap) { RealProxy.ValidateReturnArg(outArgs[index], parameters[index].ParameterType); } } } if ((message.GetCallType() & 15) != 1) { Type returnType = reflectionCachedData.ReturnType; if (returnType != (Type)null) { RealProxy.ValidateReturnArg(returnValue, returnType); } } message.PropagateOutParameters(outArgs, returnValue); }
public static extern object GetStubData(RealProxy rp);
// Invoke for case where call is in the same context as the server object // (This special static method is used for AsyncDelegate-s ... this is called // directly from the EE) private static void Invoke(Object NotUsed, ref MessageData msgData) { Message m = new Message(); m.InitFields(msgData); Object thisPtr = m.GetThisPtr(); Delegate d; if ((d = thisPtr as Delegate) != null) { RemotingProxy rp = (RemotingProxy) RemotingServices.GetRealProxy(d.Target); if (rp != null) { rp.InternalInvoke(m, true, m.GetCallType()); } else { int callType = m.GetCallType(); AsyncResult ar; switch (callType) { case Message.BeginAsync: case Message.BeginAsync | Message.OneWay: // pick up call context from the thread m.Properties[Message.CallContextKey] = CallContext.GetLogicalCallContext().Clone(); ar = new AsyncResult(m); AgileAsyncWorkerItem workItem = new AgileAsyncWorkerItem( m, ((callType & Message.OneWay) != 0) ? null : ar, d.Target); ThreadPool.QueueUserWorkItem( new WaitCallback( AgileAsyncWorkerItem.ThreadPoolCallBack), workItem); if ((callType & Message.OneWay) != 0) { ar.SyncProcessMessage(null); } m.PropagateOutParameters(null, ar); break; case (Message.EndAsync | Message.OneWay): return; case Message.EndAsync: // This will also merge back the call context // onto the thread that called EndAsync RealProxy.EndInvokeHelper(m, false); break; default: BCLDebug.Assert( false, "Should never be here. Sync delegate code for agile object ended up in remoting"); break; } } } else { // Static invoke called with incorrect this pointer ... throw new RemotingException( Environment.GetResourceString( "Remoting_Default")); } }
internal RemotingIntermediary(RealProxy pxy) : base(pxy.GetProxiedType()) { this._pxy = pxy; this._blind = new BlindMBRO((MarshalByRefObject) this.GetTransparentProxy()); }
internal MbrObject(RealProxy proxy, System.Type targetType) { this.proxy = proxy; this.targetType = targetType; }
/* this is called from unmanaged code */ internal static object PrivateInvoke(RealProxy rp, IMessage msg, out Exception exc, out object [] out_args) { //MonoMethodMessage mMsg = (MonoMethodMessage) msg; //mMsg.LogicalCallContext = CallContext.CreateLogicalCallContext (true); //CallType call_type = mMsg.CallType; //bool is_remproxy = (rp as RemotingProxy) != null; //IMethodReturnMessage res_msg = null; //if (call_type == CallType.BeginInvoke) // // todo: set CallMessage in runtime instead // mMsg.AsyncResult.CallMessage = mMsg; //if (call_type == CallType.EndInvoke) // res_msg = (IMethodReturnMessage)mMsg.AsyncResult.EndInvoke (); //// Check for constructor msg //if (mMsg.MethodBase.IsConstructor) //{ // if (is_remproxy) // res_msg = (IMethodReturnMessage) (rp as RemotingProxy).ActivateRemoteObject ((IMethodMessage) msg); // else // msg = new ConstructionCall (rp.GetProxiedType ()); //} //if (null == res_msg) //{ // res_msg = (IMethodReturnMessage)rp.Invoke (msg); // // Note, from begining this code used AsyncResult.IsCompleted for // // checking if it was a remoting or custom proxy, but in some // // cases the remoting proxy finish before the call returns // // causing this method to be called, therefore causing all kind of bugs. // if ((!is_remproxy) && call_type == CallType.BeginInvoke) // { // IMessage asyncMsg = null; // // allow calltype EndInvoke to finish // asyncMsg = mMsg.AsyncResult.SyncProcessMessage (res_msg as IMessage); // res_msg = new ReturnMessage (asyncMsg, null, 0, null, res_msg as IMethodCallMessage); // } //} //if (res_msg.LogicalCallContext != null && res_msg.LogicalCallContext.HasInfo) // CallContext.UpdateCurrentCallContext (res_msg.LogicalCallContext); //exc = res_msg.Exception; //// todo: remove throw exception from the runtime invoke //if (null != exc) { // out_args = null; // throw exc.FixRemotingException(); //} //else if (res_msg is IConstructionReturnMessage || mMsg.CallType == CallType.BeginInvoke) { // out_args = res_msg.OutArgs; //} //else if (mMsg.CallType == CallType.Sync) { // out_args = ProcessResponse (res_msg, mMsg); //} //else if (mMsg.CallType == CallType.EndInvoke) { // out_args = ProcessResponse (res_msg, mMsg.AsyncResult.CallMessage); //} //else { // out_args = res_msg.OutArgs; //} //return res_msg.ReturnValue; throw new NotImplementedException(); }
public static void SwitchWrappers (RealProxy oldcp, RealProxy newcp) { throw new NotSupportedException (); }
} // Invoke // This is called for all remoted calls on a TP except Ctors // The method called may be Sync, Async or OneWay(special case of Async) // In the Async case we come here for both BeginInvoke & EndInvoke internal virtual IMessage InternalInvoke( IMethodCallMessage reqMcmMsg, bool useDispatchMessage, int callType) { Message reqMsg = reqMcmMsg as Message; if ((reqMsg == null) && (callType != Message.Sync)) { // Only the synchronous call type is supported for messages that // aren't of type Message. throw new RemotingException( Environment.GetResourceString("Remoting_Proxy_InvalidCallType")); } IMessage retMsg = null; Thread currentThread = Thread.CurrentThread; // pick up call context from the thread LogicalCallContext cctx = currentThread.GetLogicalCallContext(); Identity idObj = IdentityObject; ServerIdentity serverID = idObj as ServerIdentity; if ((null != serverID) && idObj.IsFullyDisconnected()) { throw new ArgumentException( String.Format(Environment.GetResourceString("Remoting_ServerObjectNotFound"), reqMcmMsg.Uri)); } // Short-circuit calls to Object::GetType and Object::GetHashCode MethodBase mb = reqMcmMsg.MethodBase; if (_getTypeMethod == mb) { // Time to load the true type of the remote object.... Type t = GetProxiedType(); return(new ReturnMessage(t, null, 0, null /*cctx*/, reqMcmMsg)); } if (_getHashCodeMethod == mb) { int hashCode = idObj.GetHashCode(); return(new ReturnMessage(hashCode, null, 0, null /*cctx*/, reqMcmMsg)); } // check for channel sink if (idObj.ChannelSink == null) { throw new RemotingException( Environment.GetResourceString("Remoting_Proxy_NoChannelSink")); } // Set the identity in the message object IInternalMessage iim = (IInternalMessage)reqMcmMsg; iim.IdentityObject = idObj; if (null != serverID) { Message.DebugOut("Setting serveridentity on message \n"); iim.ServerIdentityObject = serverID; } else { // We need to set the URI only for identities that // are not the server identities. The uri is used to // dispatch methods for objects outside the appdomain. // Inside the appdomain (xcontext case) we dispatch // by getting the server object from the server identity. iim.SetURI(idObj.URI); } Message.DebugOut("InternalInvoke. Dispatching based on class type\n"); AsyncResult ar = null; switch (callType) { case Message.Sync: Message.DebugOut("RemotingProxy.Invoke Call: SyncProcessMsg\n"); BCLDebug.Assert(!useDispatchMessage, "!useDispatchMessage"); bool bSkipContextChain = false; Context currentContext = currentThread.GetCurrentContextInternal(); IMessageSink nextSink = idObj.EnvoyChain; // if we are in the default context, there can be no // client context chain, so we can skip the intermediate // calls if there are no envoy sinks if (currentContext.IsDefaultContext) { if (nextSink is EnvoyTerminatorSink) { bSkipContextChain = true; // jump directly to the channel sink nextSink = idObj.ChannelSink; } } retMsg = CallProcessMessage(nextSink, reqMcmMsg, idObj.ProxySideDynamicSinks, currentThread, currentContext, bSkipContextChain); break; case Message.BeginAsync: case Message.BeginAsync | Message.OneWay: // For async calls we clone the call context from the thread // This is a limited clone (we dont deep copy the user data) cctx = (LogicalCallContext)cctx.Clone(); iim.SetCallContext(cctx); ar = new AsyncResult(reqMsg); InternalInvokeAsync(ar, reqMsg, useDispatchMessage, callType); Message.DebugOut("Propagate out params for BeginAsync\n"); retMsg = new ReturnMessage(ar, null, 0, null /*cctx*/, reqMsg); break; case Message.OneWay: // For async calls we clone the call context from the thread // This is a limited clone (we dont deep copy the user data) cctx = (LogicalCallContext)cctx.Clone(); iim.SetCallContext(cctx); InternalInvokeAsync(null, reqMsg, useDispatchMessage, callType); retMsg = new ReturnMessage(null, null, 0, null /*cctx*/, reqMcmMsg); break; case (Message.EndAsync | Message.OneWay): retMsg = new ReturnMessage(null, null, 0, null /*cctx*/, reqMcmMsg); break; case Message.EndAsync: // For endAsync, we merge back the returned callContext // into the thread's callContext retMsg = RealProxy.EndInvokeHelper(reqMsg, true); break; } return(retMsg); }
public static void SetStubData (RealProxy rp, object stubData) { rp._stubData = stubData; }
[System.Security.SecurityCritical] // auto-generated private static bool CheckCast(RealProxy rp, RuntimeType castType) { // NOTE: This is the point where JIT_CheckCastClass ultimately // lands up in the managed world if the object being cast is // a transparent proxy. // If we are here, it means that walking the current EEClass // up the chain inside the EE was unable to verify the cast. Message.DebugOut("Entered CheckCast for type " + castType); bool fCastOK = false; BCLDebug.Assert(rp != null, "Shouldn't be called with null real proxy."); // Always return true if cast is to System.Object if (castType == typeof(Object)) return true; // We do not allow casting to non-interface types that do not extend // from System.MarshalByRefObject if (!castType.IsInterface && !castType.IsMarshalByRef) return false; // Note: this is a bit of a hack to allow deserialization of WellKnown // object refs (in the well known cases, we always return TRUE for // interface casts but doing so messes us up in the case when // the object manager is trying to resolve object references since // it ends up thinking that the proxy we returned needs to be resolved // further). if (castType != typeof(IObjectReference)) { IRemotingTypeInfo typeInfo = rp as IRemotingTypeInfo; if(null != typeInfo) { fCastOK = typeInfo.CanCastTo(castType, rp.GetTransparentProxy()); } else { // The proxy does not implement IRemotingTypeInfo, so we should // try to do casting based on the ObjRef type info. Identity id = rp.IdentityObject; if (id != null) { ObjRef objRef = id.ObjectRef; if (objRef != null) { typeInfo = objRef.TypeInfo; if (typeInfo != null) { fCastOK = typeInfo.CanCastTo(castType, rp.GetTransparentProxy()); } } } } } Message.DebugOut("CheckCast returning " + fCastOK); return fCastOK; }
internal virtual IMessage InternalInvoke(IMethodCallMessage reqMcmMsg, bool useDispatchMessage, int callType) { Message message1 = reqMcmMsg as Message; if (message1 == null && callType != 0) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_InvalidCallType")); } IMessage message2 = (IMessage)null; Thread currentThread = Thread.CurrentThread; LogicalCallContext logicalCallContext = currentThread.GetMutableExecutionContext().LogicalCallContext; Identity identityObject = this.IdentityObject; ServerIdentity serverIdentity = identityObject as ServerIdentity; if (serverIdentity != null && identityObject.IsFullyDisconnected()) { throw new ArgumentException(Environment.GetResourceString("Remoting_ServerObjectNotFound", (object)reqMcmMsg.Uri)); } MethodBase methodBase = reqMcmMsg.MethodBase; if ((MethodBase)RemotingProxy._getTypeMethod == methodBase) { return((IMessage) new ReturnMessage((object)this.GetProxiedType(), (object[])null, 0, logicalCallContext, reqMcmMsg)); } if ((MethodBase)RemotingProxy._getHashCodeMethod == methodBase) { return((IMessage) new ReturnMessage((object)identityObject.GetHashCode(), (object[])null, 0, logicalCallContext, reqMcmMsg)); } if (identityObject.ChannelSink == null) { IMessageSink chnlSink = (IMessageSink)null; IMessageSink envoySink = (IMessageSink)null; if (!identityObject.ObjectRef.IsObjRefLite()) { RemotingServices.CreateEnvoyAndChannelSinks((MarshalByRefObject)null, identityObject.ObjectRef, out chnlSink, out envoySink); } else { RemotingServices.CreateEnvoyAndChannelSinks(identityObject.ObjURI, (object)null, out chnlSink, out envoySink); } RemotingServices.SetEnvoyAndChannelSinks(identityObject, chnlSink, envoySink); if (identityObject.ChannelSink == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_NoChannelSink")); } } IInternalMessage internalMessage = (IInternalMessage)reqMcmMsg; internalMessage.IdentityObject = identityObject; if (serverIdentity != null) { internalMessage.ServerIdentityObject = serverIdentity; } else { internalMessage.SetURI(identityObject.URI); } switch (callType) { case 0: bool bSkippingContextChain = false; Context currentContextInternal = currentThread.GetCurrentContextInternal(); IMessageSink ms = identityObject.EnvoyChain; if (currentContextInternal.IsDefaultContext && ms is EnvoyTerminatorSink) { bSkippingContextChain = true; ms = identityObject.ChannelSink; } message2 = RemotingProxy.CallProcessMessage(ms, (IMessage)reqMcmMsg, identityObject.ProxySideDynamicSinks, currentThread, currentContextInternal, bSkippingContextChain); break; case 1: case 9: LogicalCallContext callContext1 = (LogicalCallContext)logicalCallContext.Clone(); internalMessage.SetCallContext(callContext1); AsyncResult asyncResult = new AsyncResult(message1); this.InternalInvokeAsync((IMessageSink)asyncResult, message1, useDispatchMessage, callType); message2 = (IMessage) new ReturnMessage((object)asyncResult, (object[])null, 0, (LogicalCallContext)null, (IMethodCallMessage)message1); break; case 2: message2 = RealProxy.EndInvokeHelper(message1, true); break; case 8: LogicalCallContext callContext2 = (LogicalCallContext)logicalCallContext.Clone(); internalMessage.SetCallContext(callContext2); this.InternalInvokeAsync((IMessageSink)null, message1, useDispatchMessage, callType); message2 = (IMessage) new ReturnMessage((object)null, (object[])null, 0, (LogicalCallContext)null, reqMcmMsg); break; case 10: message2 = (IMessage) new ReturnMessage((object)null, (object[])null, 0, (LogicalCallContext)null, reqMcmMsg); break; } return(message2); }
internal static extern Object CreateTransparentProxy( RealProxy rp, RuntimeType typeToProxy, IntPtr stub, Object stubData);
internal static bool ProxyCheckCast (RealProxy rp, RuntimeType castType) { // TODO: What should it do? return true; }
// // Summary: // Retrieves stub data that is stored for the specified proxy. // // Parameters: // rp: // The proxy for which stub data is requested. // // Returns: // Stub data for the specified proxy. // // Exceptions: // System.Security.SecurityException: // The immediate caller does not have UnmanagedCode permission. public static object GetStubData(RealProxy rp);
public IntermediaryObjRef(MarshalByRefObject mbro, Type reqtype, RealProxy pxy) : base(mbro, reqtype) { this._custom = pxy.CreateObjRef(reqtype); }
public static object GetStubData(RealProxy rp) { return(rp._stubData); }
// Get the stub data within a proxy. public static Object GetStubData(RealProxy rp) { if(rp != null) { return rp.stubData; } else { return null; } }
/* this is called from unmanaged code */ internal static object PrivateInvoke(RealProxy rp, IMessage msg, out Exception exc, out object [] out_args) { MonoMethodMessage mMsg = (MonoMethodMessage)msg; mMsg.LogicalCallContext = CallContext.CreateLogicalCallContext(true); CallType call_type = mMsg.CallType; bool is_remproxy = (rp is RemotingProxy); out_args = null; IMethodReturnMessage res_msg = null; if (call_type == CallType.BeginInvoke) { // todo: set CallMessage in runtime instead mMsg.AsyncResult.CallMessage = mMsg; } if (call_type == CallType.EndInvoke) { res_msg = (IMethodReturnMessage)mMsg.AsyncResult.EndInvoke(); } // Check for constructor msg if (mMsg.MethodBase.IsConstructor) { if (is_remproxy) { res_msg = (IMethodReturnMessage)(rp as RemotingProxy).ActivateRemoteObject((IMethodMessage)msg); } else { msg = new ConstructionCall(rp.GetProxiedType()); } } if (null == res_msg) { bool failed = false; try { res_msg = (IMethodReturnMessage)rp.Invoke(msg); } catch (Exception ex) { failed = true; if (call_type == CallType.BeginInvoke) { // If async dispatch crashes, don't propagate the exception. // The exception will be raised when calling EndInvoke. mMsg.AsyncResult.SyncProcessMessage(new ReturnMessage(ex, msg as IMethodCallMessage)); res_msg = new ReturnMessage(null, null, 0, null, msg as IMethodCallMessage); } else { throw; } } // Note, from begining this code used AsyncResult.IsCompleted for // checking if it was a remoting or custom proxy, but in some // cases the remoting proxy finish before the call returns // causing this method to be called, therefore causing all kind of bugs. if ((!is_remproxy) && call_type == CallType.BeginInvoke && !failed) { IMessage asyncMsg = null; // allow calltype EndInvoke to finish asyncMsg = mMsg.AsyncResult.SyncProcessMessage(res_msg as IMessage); out_args = res_msg.OutArgs; res_msg = new ReturnMessage(asyncMsg, null, 0, null, res_msg as IMethodCallMessage); } } if (res_msg.LogicalCallContext != null && res_msg.LogicalCallContext.HasInfo) { CallContext.UpdateCurrentCallContext(res_msg.LogicalCallContext); } exc = res_msg.Exception; // todo: remove throw exception from the runtime invoke if (null != exc) { out_args = null; throw exc.FixRemotingException(); } else if (res_msg is IConstructionReturnMessage) { if (out_args == null) { out_args = res_msg.OutArgs; } } else if (mMsg.CallType == CallType.BeginInvoke) { // We don't have OutArgs in this case. } else if (mMsg.CallType == CallType.Sync) { out_args = ProcessResponse(res_msg, mMsg); } else if (mMsg.CallType == CallType.EndInvoke) { out_args = ProcessResponse(res_msg, mMsg.AsyncResult.CallMessage); } else { if (out_args == null) { out_args = res_msg.OutArgs; } } return(res_msg.ReturnValue); }
// Set the stub data for a particular proxy. public static void SetStubData(RealProxy rp, Object stubData) { if(rp != null) { rp.stubData = stubData; } }
public static object GetStubData(RealProxy rp) { throw new NotImplementedException(); }
internal static object PrivateInvoke(RealProxy rp, IMessage msg, out Exception exc, out object [] out_args) { throw new PlatformNotSupportedException(); }
public static object GetStubData (RealProxy rp) { return rp._stubData; }
public RemotingInvocation(RealProxy realProxy, IMethodCallMessage message) { _message = message; _realProxy = realProxy; this._args = (object[])this._message.Properties["__Args"]; }
/* this is called from unmanaged code */ internal static object PrivateInvoke (RealProxy rp, IMessage msg, out Exception exc, out object [] out_args) { MonoMethodMessage mMsg = (MonoMethodMessage) msg; mMsg.LogicalCallContext = CallContext.CreateLogicalCallContext (true); CallType call_type = mMsg.CallType; #if MOONLIGHT bool is_remproxy = false; #else bool is_remproxy = (rp is RemotingProxy); #endif out_args = null; IMethodReturnMessage res_msg = null; if (call_type == CallType.BeginInvoke) // todo: set CallMessage in runtime instead mMsg.AsyncResult.CallMessage = mMsg; if (call_type == CallType.EndInvoke) res_msg = (IMethodReturnMessage)mMsg.AsyncResult.EndInvoke (); // Check for constructor msg if (mMsg.MethodBase.IsConstructor) { #if !MOONLIGHT if (is_remproxy) res_msg = (IMethodReturnMessage) (rp as RemotingProxy).ActivateRemoteObject ((IMethodMessage) msg); else #endif msg = new ConstructionCall (rp.GetProxiedType ()); } if (null == res_msg) { bool failed = false; try { res_msg = (IMethodReturnMessage)rp.Invoke (msg); } catch (Exception ex) { failed = true; if (call_type == CallType.BeginInvoke) { // If async dispatch crashes, don't propagate the exception. // The exception will be raised when calling EndInvoke. mMsg.AsyncResult.SyncProcessMessage (new ReturnMessage (ex, msg as IMethodCallMessage)); res_msg = new ReturnMessage (null, null, 0, null, msg as IMethodCallMessage); } else throw; } // Note, from begining this code used AsyncResult.IsCompleted for // checking if it was a remoting or custom proxy, but in some // cases the remoting proxy finish before the call returns // causing this method to be called, therefore causing all kind of bugs. if ((!is_remproxy) && call_type == CallType.BeginInvoke && !failed) { IMessage asyncMsg = null; // allow calltype EndInvoke to finish asyncMsg = mMsg.AsyncResult.SyncProcessMessage (res_msg as IMessage); out_args = res_msg.OutArgs; res_msg = new ReturnMessage (asyncMsg, null, 0, null, res_msg as IMethodCallMessage); } } if (res_msg.LogicalCallContext != null && res_msg.LogicalCallContext.HasInfo) CallContext.UpdateCurrentCallContext (res_msg.LogicalCallContext); exc = res_msg.Exception; // todo: remove throw exception from the runtime invoke if (null != exc) { out_args = null; throw exc.FixRemotingException(); } else if (res_msg is IConstructionReturnMessage) { if (out_args == null) out_args = res_msg.OutArgs; } else if (mMsg.CallType == CallType.BeginInvoke) { // We don't have OutArgs in this case. } else if (mMsg.CallType == CallType.Sync) { out_args = ProcessResponse (res_msg, mMsg); } else if (mMsg.CallType == CallType.EndInvoke) { out_args = ProcessResponse (res_msg, mMsg.AsyncResult.CallMessage); } else { if (out_args == null) out_args = res_msg.OutArgs; } return res_msg.ReturnValue; }
public TransparentProxyFactory(Type objectType) { this.objectType = objectType; this.realProxy = new RemotingProxy(); }