Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/corlib/System.Runtime.Remoting.Proxies/ChangeLog

@@ -0,0 +1,222 @@
+2010-02-28  Robert Jordan  <robertj@gmx.net>
+
+	* RealProxy.cs (PrivateInvoke): BeginInvoke return messages
+	do not have out args (by design). The issue has existed for many
+	years but it was invisible because mono_delegate_begin_invoke ()
+	has swallowed exceptions, which was fixed by Gonzalo in r141856.
+	Fixes a couple of disabled remoting tests (#576618).
+
+2009-09-27 Gonzalo Paniagua Javier <gonzalo@novell.com>
+
+	* RealProxy.cs: for a custom proxy, retrieve the OutArgs before
+	allowing EndInvoke to proceed because after that, OutArgs will throw
+	because there is no method. Fixes remoting2 and remoting3 tests.
+
+2009-05-06  Lluis Sanchez Gual  <lluis@novell.com>
+
+	* RealProxy.cs: If async dispatch crashes, don't propagate the
+	exception. The exception will be raised when calling EndInvoke.
+
+2008-04-02  Andreas Nahr  <ClassDevelopment@A-SoftTech.com>
+
+	* ProxyAttribute.cs: Fix parameter names
+
+2008-02-10  Sebastien Pouliot  <sebastien@ximian.com>
+
+	* RealProxy.cs: Use 'is' instead of 'as' and a null check. Found 
+	using Gendarme new UseIsOperator rule.
+
+2007-05-03  Dick Porter  <dick@ximian.com>
+
+	* ProxyAttribute.cs: 
+	* RealProxy.cs: Update to 2.0 profile
+
+2006-07-15  Jonathan Chambers  <joncham@gmail.com>
+
+	* RealProxy.cs: Indicate that all fields need keep in sync
+	with definition in object-internals.h for COM Interop.
+	
+2006-06-18  Zoltan Varga  <vargaz@gmail.com>
+
+	* RealProxy.cs (ProcessResponse): Use t.GetElementType ().IsInstanceOfType () when the type is a byref.
+
+2005-06-22  Lluis Sanchez Gual  <lluis@novell.com>
+
+	* RealProxy.cs: Extract the output arguments from the message's
+	Args list (not from OutArgs), since some message objects
+	may not support OutArgs (for example, when the target MethodBase is
+	not known, there is no way to know which params are out params).
+	I've checked that MS.NET behaves in the same way. This fixes
+	bug #75277.
+
+2005-06-13  Lluis Sanchez Gual  <lluis@novell.com>
+
+	* RealProxy.cs: Report invalid return type of values using
+	InvalidCastException, like MS.NET. Fixes bug #75203.
+
+2004-10-26  Lluis Sanchez Gual  <lluis@novell.com>
+
+	* RealProxy.cs: Added _targetDomainId and _targetUri fields, which are
+	used by the new xdomain wrappers. Added GetAppDomainTarget() method,
+	which returns the remote object referenced by the proxy.
+	* RemotingProxy.cs: Moved _targetUri to RealProxy.
+
+2004-09-27  Lluis Sanchez Gual  <lluis@novell.com>
+
+	* RemotingProxy.cs: In Invoke, suport IMessages other than MonoMessage.
+	
+2004-09-22  Lluis Sanchez Gual  <lluis@novell.com>
+
+	* RemotingProxy.cs: When attaching a CBO identity, assign the proxy to
+	  be used as "this" for method calls.
+
+2004-04-23	Patrik Torstensson
+
+	* RealProxy.cs: Moved async functionlity here, also take
+	care of custom proxies (non RemotingProxy) case for async and
+	construction calls.
+	
+	* RemotingProxy.cs: allow RealProxy to call construction method and
+	remove end async control (moved to RealProxy)
+	
+	Fixes remoting2/3 test case (mono/mono/tests) and closes bug #57672.
+
+2004-04-13  Lluis Sanchez Gual  <lluis@ximian.com>
+
+	* RealProxy.cs: IRemotingTypeInfo.TypeName can return null, beware of that.
+
+2004-04-01  Lluis Sanchez Gual  <lluis@ximian.com>
+
+	* RemotingProxy.cs: Changed the rules for casting WKO proxies, to match
+	  MS.NET behavior.
+
+2004-03-04  Lluis Sanchez Gual  <lluis@ximian.com>
+
+	* RealProxy.cs: Added new internal method for getting the proxy type. It
+	  gets the proxy type from the MonoRemoteClass (it can change if the
+	  vtable is upgraded).
+	  Modified GetTransparentProxy(). Now it takes the name of the type.
+	  The name is taken from the IRemotingTypeInfo object.
+	* RemotingProxy.cs: The class must implement IRemotingTypeInfo.
+
+2004-01-19  Lluis Sanchez Gual  <lluis@ximian.com>
+
+	* RealProxy.cs: Added setter for ObjectIdentity.
+
+2003-11-26  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RealProxy.cs: Signature fix.
+	
+2003-11-25  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RealProxy.cs: Added some missing methods.
+	* RemotingProxy.cs: ActivateRemoteObject() must return a ConstructionResponse
+	  instead of a ReturnMessage.
+
+2003-11-11  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: Do not dispose proxy identity when it is a local
+	  ContextBoundObject proxy.
+
+2003-10-21  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RealProxy.cs: In PrivateInvoke() do not try to return the out parameters
+	  if the return message is an excption. This fixes bug #49926.
+	
+2003-10-08  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: Added destructor that unregisters the identity.
+	  Fixes a memory leak.
+
+2003-10-07  Lluis Sanchez Gual  <lluis@ximian.com>
+
+	* RealProxy.cs: Fixed support for [out] parameters in async calls.
+
+2003-09-11  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: Return message check moved to RealProxy.
+	* RealProxy.cs: Added return message check and propagation of output
+	  parameter values.
+
+2003-08-25  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: Use CallType property to check the type of
+	  the message.
+
+2003-08-24  Vladimir Vukicevic  <vladimir@pobox.com>
+
+	* RealProxy.cs, RemotingProxy.cs: move the LogicalCallContext
+	setup/restoration into RealProxy's PrivateInvoke, so that custom
+	RealProxy's get a LogicalCallContext.
+
+2003-08-14  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: On invoke, set the LogicalCallContext of the message.
+
+2003-07-28  Duncan Mak  <duncan@ximian.com>
+
+	* RealProxy.cs (GetProxiedType): Removed 'virtual' keyword.
+
+2003-07-25  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: Check the return arguments types. (a wrong type
+	  would make the runtime to crash).
+
+2003-07-16  Lluis Sanchez Gual <lluis@ximian.com>
+
+	* RemotingProxy.cs: Assign to the message the full uri, if available,
+	  not only the object uri.
+
+2003-04-10  Lluis Sanchez Gual <lluis@ideary.com>
+
+	* RemotingProxy.cs: Added support for Async and OneWay messages.
+
+2003-03-20  Lluis Sanchez Gual <lluis@ideary.com>
+
+	* RealProxy.cs: added variables to support proxy bypass when the called CBO is
+	  in the same context as the caller.
+	* RemotingProxy.cs: added suport for dynamic sinks. Activation code moved to
+	  ActivationServices.
+
+2003-03-03  Lluis Sanchez Gual <lluis@ideary.com>
+
+	* ProxyAttribute.cs: Implemented.
+	* RealProxy.cs: Added stubs for some missing methods.
+	* RemotingProxy.cs: The activation constructor now creates the ConstructionCall
+	  message and collects the context properties.
+	  Activation of objects now use IActivator instances.
+
+2003-02-18  Lluis Sanchez Gual <lluis@ideary.com>
+
+	* RealProxy.cs: Changed constructor to allow only ClientIdentity instances. 
+	* RemotingProxy.cs: Added new constructor for client activated objects.
+	  Added method that handles construction messages.
+
+2003-02-03 Patrik Torstensson
+
+	* RealProxy.cs: changed excption behavior and added serialization helpers, 
+	  changed so it don't create a new TP for each gettp call.
+	
+	* RemotingProxy.cs: added functions to short cut calls to GetHashCode and GetType,
+	same behavior as MS.
+
+2003-01-28  Gonzalo Paniagua Javier <gonzalo@ximian.com>
+
+	* RealProxy.cs: fixed compilation by adding missing GetObjectData ().
+
+2002-12-20  Lluis Sanchez Gual <lluis@ideary.com>
+
+	* RealProxy.cs: Added ObjectIdentity property. 
+	  Implemented CrateObjRef.
+	* RemotingProxy.cs: Added Identity parameter to constructor
+
+2002-07-24  Duncan Mak  <duncan@ximian.com>
+
+	* ProxyAttribute.cs: Revert the last commit.
+
+	* System.Runtime.Remoting.Proxies/ProxyAttribute.cs: This
+	implements IContextAttribute.
+
+2002-07-23  Duncan Mak  <duncan@ximian.com>	
+	
+	* System.Runtime.Remoting.Proxies/ProxyAttribute.cs: Added.

mcs/class/corlib/System.Runtime.Remoting.Proxies/ProxyAttribute.cs

@@ -0,0 +1,74 @@
+//
+// System.Runtime.Remoting.Proxies.ProxyAttribute.cs
+//
+// Author: Duncan Mak  (duncan@ximian.com)
+//
+// Copyright (C) Ximian, Inc 2002.
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Activation;
+using System.Runtime.Remoting.Contexts;
+using System.Runtime.Remoting.Channels;
+
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.Remoting.Proxies {
+
+	[AttributeUsage (AttributeTargets.Class)]
+	[ComVisible (true)]
+	public class ProxyAttribute : Attribute, IContextAttribute
+	{
+		public ProxyAttribute ()
+		{
+		}
+
+		public virtual MarshalByRefObject CreateInstance (Type serverType)
+		{
+			RemotingProxy proxy = new RemotingProxy (serverType, ChannelServices.CrossContextUrl, null);
+			return (MarshalByRefObject) proxy.GetTransparentProxy();
+		}
+
+		public virtual RealProxy CreateProxy (ObjRef objRef, Type serverType, object serverObject, Context serverContext)
+		{
+			return RemotingServices.GetRealProxy (RemotingServices.GetProxyForRemoteObject (objRef, serverType));
+		}
+
+		[ComVisible (true)]
+		public void GetPropertiesForNewContext (IConstructionCallMessage msg)
+		{
+			// Nothing to add
+		}
+
+		[ComVisible (true)]
+		public bool IsContextOK (Context ctx, IConstructionCallMessage msg)
+		{
+			return true;
+		}
+	}
+}
+

mcs/class/corlib/System.Runtime.Remoting.Proxies/RealProxy.cs

@@ -0,0 +1,362 @@
+//
+// System.Runtime.Remoting.Proxies.RealProxy.cs
+//
+// Authors:
+//   Dietmar Maurer (dietmar@ximian.com)
+//   Lluis Sanchez (lsg@ctv.es)
+//   Patrik Torstensson
+//
+// (C) 2001 Ximian, Inc.  http://www.ximian.com
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Reflection;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Messaging;
+using System.Runtime.Remoting.Activation;
+using System.Runtime.Remoting.Contexts;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace System.Runtime.Remoting.Proxies
+{
+#pragma warning disable 169, 649
+	[StructLayout (LayoutKind.Sequential)]
+	internal class TransparentProxy {
+		public RealProxy _rp;
+		IntPtr _class;
+		bool _custom_type_info;
+	}
+#pragma warning restore 169, 649
+	
+	[ComVisible (true)]
+	[StructLayout (LayoutKind.Sequential)]
+	public abstract class RealProxy {
+		// other classes visible to the runtime 
+		// derive from this class so keep these locals
+		// in sync with the definition RealProxy 
+		// in object-internals.h
+		
+#pragma warning disable 169, 414		
+		#region Sync with object-internals.h
+		Type class_to_proxy;
+		internal Context _targetContext;
+		MarshalByRefObject _server;
+		int _targetDomainId = -1;
+		internal string _targetUri;
+		internal Identity _objectIdentity;
+		Object _objTP;
+		object _stubData;
+        #endregion
+#pragma warning restore 169, 414
+
+		protected RealProxy ()
+		{
+		}
+
+		protected RealProxy (Type classToProxy) : this(classToProxy, IntPtr.Zero, null)
+		{
+		}
+
+		internal RealProxy (Type classToProxy, ClientIdentity identity) : this(classToProxy, IntPtr.Zero, null)
+		{
+			_objectIdentity = identity;
+		}
+
+		protected RealProxy (Type classToProxy, IntPtr stub, object stubData)
+		{
+			if (!classToProxy.IsMarshalByRef && !classToProxy.IsInterface)
+				throw new ArgumentException("object must be MarshalByRef");
+
+			this.class_to_proxy = classToProxy;
+
+			if (stub != IntPtr.Zero)
+				throw new NotSupportedException ("stub is not used in Mono");
+		}
+
+		[MethodImplAttribute(MethodImplOptions.InternalCall)]
+		extern static Type InternalGetProxyType (object transparentProxy);
+		
+		public Type GetProxiedType() 
+		{
+			if (_objTP == null) {
+				if (class_to_proxy.IsInterface) return typeof(MarshalByRefObject);
+				else return class_to_proxy;
+			}
+			return InternalGetProxyType (_objTP);
+		}
+
+		public virtual ObjRef CreateObjRef (Type requestedType)
+		{
+			return RemotingServices.Marshal ((MarshalByRefObject) GetTransparentProxy(), null, requestedType);
+		}
+
+		public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
+		{
+			Object obj = GetTransparentProxy();
+			RemotingServices.GetObjectData (obj, info, context);            
+		}
+		
+		internal Identity ObjectIdentity
+		{
+			get { return _objectIdentity; }
+			set { _objectIdentity = value; }
+		}
+		
+		[MonoTODO]
+		public virtual IntPtr GetCOMIUnknown (bool fIsMarshalled)
+		{
+			throw new NotImplementedException ();
+		}
+		
+		[MonoTODO]
+		public virtual void SetCOMIUnknown (IntPtr i)
+		{
+			throw new NotImplementedException ();
+		}
+		
+		[MonoTODO]
+		public virtual IntPtr SupportsInterface (ref Guid iid)
+		{
+			throw new NotImplementedException ();
+		}
+		
+		public static object GetStubData (RealProxy rp)
+		{
+			return rp._stubData;
+		}
+		
+		public static void SetStubData (RealProxy rp, object stubData)
+		{
+			rp._stubData = stubData;
+		}
+
+		public abstract IMessage Invoke (IMessage msg);
+
+		/* 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 = ExecutionContext.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.UpdateCurrentLogicalCallContext (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;
+		}
+
+		[MethodImplAttribute(MethodImplOptions.InternalCall)]
+		internal extern virtual object InternalGetTransparentProxy (string className);
+
+		public virtual object GetTransparentProxy () 
+		{
+			if (_objTP == null) 
+			{
+				string name;
+				IRemotingTypeInfo rti = this as IRemotingTypeInfo;
+				
+				if (rti != null) {
+					name = rti.TypeName;
+					if (name == null || name == typeof(MarshalByRefObject).AssemblyQualifiedName)
+						name = class_to_proxy.AssemblyQualifiedName;
+				}
+				else
+					name = class_to_proxy.AssemblyQualifiedName;
+					
+				_objTP = InternalGetTransparentProxy (name);
+			}
+			return _objTP;
+		}
+
+		[MonoTODO]
+		[ComVisible (true)]
+		public IConstructionReturnMessage InitializeServerObject(IConstructionCallMessage ctorMsg)
+		{
+			throw new NotImplementedException();
+		}
+
+		protected void AttachServer(MarshalByRefObject s)
+		{
+			_server = s;
+		}
+
+		protected MarshalByRefObject DetachServer()
+		{
+			MarshalByRefObject ob = _server;
+			_server = null;
+			return ob;
+		}
+
+		protected MarshalByRefObject GetUnwrappedServer()
+		{
+			return _server;
+		}
+		
+		internal void SetTargetDomain (int domainId)
+		{
+			_targetDomainId = domainId;
+		}
+		
+		// Called by the runtime
+		internal object GetAppDomainTarget ()
+		{
+			if (_server == null) {
+				ClientActivatedIdentity identity = RemotingServices.GetIdentityForUri (_targetUri) as ClientActivatedIdentity;
+				if (identity == null) throw new RemotingException ("Server for uri '" + _targetUri + "' not found");
+				_server = identity.GetServerObject ();
+			}
+			return _server;
+		}
+
+		static object[] ProcessResponse (IMethodReturnMessage mrm, MonoMethodMessage call)
+		{
+			// Check return type
+
+			MethodInfo mi = (MethodInfo) call.MethodBase;
+			if (mrm.ReturnValue != null && !mi.ReturnType.IsInstanceOfType (mrm.ReturnValue))
+				throw new InvalidCastException ("Return value has an invalid type");
+
+			// Check out parameters
+
+			
+			int no;
+			
+			if (call.NeedsOutProcessing (out no))
+			{
+				ParameterInfo[] parameters = mi.GetParameters();
+				object[] outArgs = new object [no];
+				int narg = 0;
+	
+				foreach (ParameterInfo par in parameters)
+				{
+					if (par.IsOut && !par.ParameterType.IsByRef)
+					{
+						// Special marshalling required
+						object outArg = par.Position < mrm.ArgCount ? mrm.GetArg (par.Position) : null;
+						if (outArg != null) {
+							object local = call.GetArg (par.Position);
+							if (local == null) throw new RemotingException ("Unexpected null value in local out parameter '" + par.Name + "'");
+							RemotingServices.UpdateOutArgObject (par, local, outArg);
+						}
+					}
+					else if (par.ParameterType.IsByRef)
+					{
+						object outArg = par.Position < mrm.ArgCount ? mrm.GetArg (par.Position) : null;
+						if (outArg != null && !par.ParameterType.GetElementType ().IsInstanceOfType (outArg))
+						{
+							throw new InvalidCastException ("Return argument '" + par.Name + "' has an invalid type");
+						}
+						outArgs [narg++] = outArg;
+					}
+				}
+				return outArgs;
+			}
+			else
+				return new object [0];
+		}
+	}
+}

mcs/class/corlib/System.Runtime.Remoting.Proxies/RemotingProxy.cs

@@ -0,0 +1,191 @@
+//
+// System.Runtime.Remoting.Proxies.RemotingProxy.cs
+//
+// Authors:
+//   Dietmar Maurer (dietmar@ximian.com)
+//   Lluis Sanchez Gual (lsg@ctv.es)
+//
+// (C) 2001 Ximian, Inc.  http://www.ximian.com
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Reflection;
+using System.Runtime.Remoting.Messaging;
+using System.Runtime.Remoting.Activation;
+using System.Runtime.Remoting.Channels;
+using System.Runtime.Remoting.Contexts;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+
+namespace System.Runtime.Remoting.Proxies
+{
+
+	internal class RemotingProxy : RealProxy, IRemotingTypeInfo
+	{
+		static MethodInfo _cache_GetTypeMethod = typeof(System.Object).GetMethod("GetType");
+		static MethodInfo _cache_GetHashCodeMethod = typeof(System.Object).GetMethod("GetHashCode");
+
+		IMessageSink _sink;
+		bool _hasEnvoySink;
+		ConstructionCall _ctorCall;
+
+		internal RemotingProxy (Type type, ClientIdentity identity) : base (type, identity)
+		{
+			_sink = identity.ChannelSink;
+			_hasEnvoySink = false;
+			_targetUri = identity.TargetUri;
+		}
+
+		internal RemotingProxy (Type type, string activationUrl, object[] activationAttributes) : base (type)
+		{
+			_hasEnvoySink = false;
+			_ctorCall = ActivationServices.CreateConstructionCall (type, activationUrl, activationAttributes);
+		}
+
+		public override IMessage Invoke (IMessage request)
+		{
+			IMethodCallMessage mm = request as IMethodCallMessage;
+
+			if (mm != null) {
+				if (mm.MethodBase == _cache_GetHashCodeMethod)
+					return new MethodResponse(ObjectIdentity.GetHashCode(), null, null, mm);
+	
+				if (mm.MethodBase == _cache_GetTypeMethod)
+					return new MethodResponse(GetProxiedType(), null, null, mm);
+			}
+			
+			IInternalMessage im = request as IInternalMessage;
+			if (im != null) {
+				if (im.Uri == null) im.Uri = _targetUri;
+				im.TargetIdentity = _objectIdentity;
+			}
+
+			_objectIdentity.NotifyClientDynamicSinks (true, request, true, false);
+
+			IMessage response;
+			IMessageSink sink;
+
+			// Needs to go through the client context sink?
+			if (Thread.CurrentContext.HasExitSinks && !_hasEnvoySink)
+				sink = Thread.CurrentContext.GetClientContextSinkChain ();
+			else
+				sink = _sink;
+
+			MonoMethodMessage mMsg = request as MonoMethodMessage;
+			if (mMsg == null || mMsg.CallType == CallType.Sync)
+				response = sink.SyncProcessMessage (request);
+			else
+			{
+				AsyncResult ares = mMsg.AsyncResult;
+				IMessageCtrl mctrl = sink.AsyncProcessMessage (request, ares);
+				if (ares != null) ares.SetMessageCtrl (mctrl);
+				response = new ReturnMessage (null, new object[0], 0, null, mMsg);
+			}
+
+			_objectIdentity.NotifyClientDynamicSinks (false, request, true, false);
+
+			return response;
+		}
+
+		internal void AttachIdentity (Identity identity)
+		{
+			_objectIdentity = identity;
+
+			if (identity is ClientActivatedIdentity)	// It is a CBO
+			{
+				ClientActivatedIdentity cai = (ClientActivatedIdentity)identity;
+				_targetContext = cai.Context;
+				AttachServer (cai.GetServerObject ());
+				cai.SetClientProxy ((MarshalByRefObject) GetTransparentProxy());
+			}
+
+			if (identity is ClientIdentity)
+			{
+				((ClientIdentity)identity).ClientProxy = (MarshalByRefObject) GetTransparentProxy();
+				_targetUri = ((ClientIdentity)identity).TargetUri;
+			}
+			else
+				_targetUri = identity.ObjectUri;
+
+			if (_objectIdentity.EnvoySink != null)
+			{
+				_sink = _objectIdentity.EnvoySink;
+				_hasEnvoySink = true;
+			}
+			else 
+				_sink = _objectIdentity.ChannelSink;
+
+			_ctorCall = null;	// Object already constructed
+		}
+
+		internal IMessage ActivateRemoteObject (IMethodMessage request)
+		{
+			if (_ctorCall == null)	// It must be a WKO
+				return new ConstructionResponse (this, null, (IMethodCallMessage) request);	// Ignore constructor call for WKOs
+
+			_ctorCall.CopyFrom (request);
+			return ActivationServices.Activate (this, _ctorCall);
+		}
+
+		public string TypeName 
+		{ 
+			get
+			{
+				if (_objectIdentity is ClientIdentity) {
+					ObjRef oref = _objectIdentity.CreateObjRef (null);
+					if (oref.TypeInfo != null) return oref.TypeInfo.TypeName;
+				}
+				return GetProxiedType().AssemblyQualifiedName;
+			}
+			
+			set
+			{
+				throw new NotSupportedException ();
+			}
+		}
+		
+		public bool CanCastTo (Type fromType, object o)
+		{
+			if (_objectIdentity is ClientIdentity) {
+				ObjRef oref = _objectIdentity.CreateObjRef (null);
+				if (oref.IsReferenceToWellKnow && (fromType.IsInterface || GetProxiedType() == typeof(MarshalByRefObject))) return true;
+				if (oref.TypeInfo != null) return oref.TypeInfo.CanCastTo (fromType, o);
+			}
+			return fromType.IsAssignableFrom (GetProxiedType());
+		}
+		
+		~RemotingProxy()
+		{
+			if (_objectIdentity != null)
+			{
+				if (!(_objectIdentity is ClientActivatedIdentity))	// Local CBO proxy?
+					RemotingServices.DisposeIdentity (_objectIdentity);
+			}
+		}
+		
+	}
+}